Giter Club home page Giter Club logo

cordova-sqlite-ext's Introduction

Cordova/PhoneGap sqlite storage adapter with extra features

Native SQLite component with API based on HTML5/Web SQL (DRAFT) API for the following platforms:

  • Android
  • iOS
  • macOS ("osx" platform)
  • Windows 10 (UWP) DESKTOP and MOBILE (see below for major limitations)

LICENSE: MIT, with Apache 2.0 option for Android and Windows platforms (see LICENSE.md for details, including third-party components used by this plugin)

WARNINGS

Comparison of supported plugin versions

Free license terms Commercial license & support
cordova-sqlite-storage - core plugin version MIT (or Apache 2.0 on Android & Windows)
cordova-sqlite-express-build-support - using built-in SQLite libraries on Android, iOS, and macOS MIT (or Apache 2.0 on Android & Windows)
cordova-sqlite-ext - with extra features including BASE64, REGEXP, and pre-populated databases MIT (or Apache 2.0 on Android & Windows)
cordova-sqlite-evcore-extbuild-free - plugin version with lighter resource usage in Android NDK GPL v3 available, see https://xpbrew.consulting/
cordova-plugin-sqlite-evplus-ext-common-free - includes workaround for extra-large result data on Android and lighter resource usage on iOS, macOS, and in Android NDK GPL v3 available, see https://xpbrew.consulting/

COMING SOON

New SQLite plugin design with a simpler API is in progress with a working demo - see brodybits/ask-me-anything#3

Breaking changes coming soon

in an upcoming major release - see xpbrew/cordova-sqlite-storage#922

some highlights:

  • error code will always be 0 (which is already the case on Windows); actual SQLite3 error code will be part of the error message member whenever possible (see xpbrew/cordova-sqlite-storage#821)
  • drop support for location: 0-2 values in openDatabase call (please use location: 'default' or iosDatabaseLocation setting in openDatabase as documented below)
  • throw an exception in case of androidDatabaseImplementation: 2 setting which is now superseded by androidDatabaseProvider: 'system' setting

under consideration:

About this plugin version

Version with extra features: REGEXP (Android/iOS/macOS), BASE64, BLOBFROMBASE64, and pre-populated databases

This plugin version uses a before_plugin_install hook to install sqlite3 library dependencies from cordova-sqlite-ext-deps via npm.

WARNING: Multiple SQLite problem on multiple platforms

Multiple SQLite problem on Android

This plugin uses non-standard android-sqlite-native-ndk-connector implementation with android-sqlite-ndk-native-driver on Android. In case an application access the same database using multiple plugins there is a risk of data corruption ref: storesafe/cordova-sqlite-storage#626) as described in http://ericsink.com/entries/multiple_sqlite_problem.html and https://www.sqlite.org/howtocorrupt.html.

The workaround is to use the androidDatabaseProvider: 'system' setting as described in the Android database provider section below:

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

Multiple SQLite problem on other platforms

This plugin version also uses a fixed version of sqlite3 on iOS, macOS, and Windows. In case the application accesses the SAME database using multiple plugins there is a risk of data corruption as described in https://www.sqlite.org/howtocorrupt.html (similar to the multiple sqlite problem for Android as described in http://ericsink.com/entries/multiple_sqlite_problem.html).

A quick tour

To open a database:

var db = null;

document.addEventListener('deviceready', function() {
  db = window.sqlitePlugin.openDatabase({
    name: 'my.db',
    location: 'default',
  });
});

IMPORTANT: Like with the other Cordova plugins your application must wait for the deviceready event. This is especially tricky in Angular/ngCordova/Ionic controller/factory/service callbacks which may be triggered before the deviceready event is fired.

Using DRAFT standard transaction API

To populate a database using the DRAFT standard transaction API:

  db.transaction(function(tx) {
    tx.executeSql('CREATE TABLE IF NOT EXISTS DemoTable (name, score)');
    tx.executeSql('INSERT INTO DemoTable VALUES (?,?)', ['Alice', 101]);
    tx.executeSql('INSERT INTO DemoTable VALUES (?,?)', ['Betty', 202]);
  }, function(error) {
    console.log('Transaction ERROR: ' + error.message);
  }, function() {
    console.log('Populated database OK');
  });

or using numbered parameters as documented in https://www.sqlite.org/c3ref/bind_blob.html:

  db.transaction(function(tx) {
    tx.executeSql('CREATE TABLE IF NOT EXISTS DemoTable (name, score)');
    tx.executeSql('INSERT INTO DemoTable VALUES (?1,?2)', ['Alice', 101]);
    tx.executeSql('INSERT INTO DemoTable VALUES (?1,?2)', ['Betty', 202]);
  }, function(error) {
    console.log('Transaction ERROR: ' + error.message);
  }, function() {
    console.log('Populated database OK');
  });

To check the data using the DRAFT standard transaction API:

  db.transaction(function(tx) {
    tx.executeSql('SELECT count(*) AS mycount FROM DemoTable', [], function(tx, rs) {
      console.log('Record count (expected to be 2): ' + rs.rows.item(0).mycount);
    }, function(tx, error) {
      console.log('SELECT error: ' + error.message);
    });
  });

Using plugin-specific API calls

To populate a database using the SQL batch API:

  db.sqlBatch([
    'CREATE TABLE IF NOT EXISTS DemoTable (name, score)',
    [ 'INSERT INTO DemoTable VALUES (?,?)', ['Alice', 101] ],
    [ 'INSERT INTO DemoTable VALUES (?,?)', ['Betty', 202] ],
  ], function() {
    console.log('Populated database OK');
  }, function(error) {
    console.log('SQL batch ERROR: ' + error.message);
  });

or using numbered parameters as documented in https://www.sqlite.org/c3ref/bind_blob.html:

  db.sqlBatch([
    'CREATE TABLE IF NOT EXISTS DemoTable (name, score)',
    [ 'INSERT INTO DemoTable VALUES (?1,?2)', ['Alice', 101] ],
    [ 'INSERT INTO DemoTable VALUES (?1,?2)', ['Betty', 202] ],
  ], function() {
    console.log('Populated database OK');
  }, function(error) {
    console.log('SQL batch ERROR: ' + error.message);
  });

To check the data using the single SQL statement API:

  db.executeSql('SELECT count(*) AS mycount FROM DemoTable', [], function(rs) {
    console.log('Record count (expected to be 2): ' + rs.rows.item(0).mycount);
  }, function(error) {
    console.log('SELECT SQL statement ERROR: ' + error.message);
  });

More detailed sample

See the Sample section for a sample with a more detailed explanation (using the DRAFT standard transaction API).

Status

  • This plugin is not supported by PhoneGap Developer App or PhoneGap Desktop App.
  • A recent version of the Cordova CLI is recommended. Known issues with older versions of Cordova:
    • Cordova pre-7.0.0 do not automatically save the state of added plugins and platforms (--save flag is needed for Cordova pre-7.0.0)
    • It may be needed to use cordova prepare in case of cordova-ios pre-4.3.0 (Cordova CLI 6.4.0).
    • Cordova versions older than 6.0.0 are missing the [email protected] security fixes.
  • This plugin version uses a before_plugin_install hook to install sqlite3 library dependencies from cordova-sqlite-storage-dependencies via npm.
  • Use of other systems such as Cordova Plugman, PhoneGap CLI, PhoneGap Build, and Intel XDK is no longer supported by this plugin version since they do not honor the before_plugin_install hook. The supported solution is to use litehelpers / Cordova-sqlite-evcore-extbuild-free (GPL or commercial license terms); deprecated alternative with permissive license terms is available at: brodybits / cordova-sqlite-legacy-build-support (very limited testing, very limited updates).
  • This plugin version includes the following extra (non-standard) features:
  • BLOB column values are NO LONGER automatically converted to Base64 format. MUST use SELECT BASE64(column) to return column value in Base64 format as documented below.
  • SQLite 3.32.3 included when building (all platforms), with the following compile-time definitions:
    • SQLITE_THREADSAFE=1
    • SQLITE_DEFAULT_SYNCHRONOUS=3 (EXTRA DURABLE build setting) ref: xpbrew/cordova-sqlite-storage#736
    • SQLITE_DEFAULT_MEMSTATUS=0
    • SQLITE_OMIT_DECLTYPE
    • SQLITE_OMIT_DEPRECATED
    • SQLITE_OMIT_PROGRESS_CALLBACK
    • SQLITE_OMIT_SHARED_CACHE
    • SQLITE_TEMP_STORE=2
    • SQLITE_OMIT_LOAD_EXTENSION
    • SQLITE_ENABLE_FTS3
    • SQLITE_ENABLE_FTS3_PARENTHESIS
    • SQLITE_ENABLE_FTS4
    • SQLITE_ENABLE_FTS5
    • SQLITE_ENABLE_RTREE
    • SQLITE_ENABLE_JSON1
    • SQLITE_ENABLE_RTREE
    • SQLITE_DEFAULT_PAGE_SIZE=4096 - new default page size ref: http://sqlite.org/pgszchng2016.html
    • SQLITE_DEFAULT_CACHE_SIZE=-2000 - new default cache size ref: http://sqlite.org/pgszchng2016.html
    • SQLITE_OS_WINRT (Windows only)
    • NDEBUG on Windows (Release build only)
  • SQLITE_DBCONFIG_DEFENSIVE flag is used for extra SQL safety on all platforms Android/iOS/macOS/Windows ref:
  • The iOS database location is now mandatory, as documented below.
  • This version branch supports the use of two (2) possible Android sqlite database implementations:
  • Support for WP8 along with Windows 8.1/Windows Phone 8.1/Windows 10 using Visual Studio 2015 is available in: brodybits / cordova-sqlite-legacy-build-support
  • Amazon Fire-OS is dropped due to lack of support by Cordova. Android platform version should be used to deploy to Fire-OS 5.0(+) devices. For reference: cordova/cordova-discuss#32 (comment)
  • Windows platform version using a customized version of the performant doo / SQLite3-WinRT C++ component based on the brodybits/SQLite3-WinRT sync-api-fix branch, with the following known limitations:
    • This plugin version branch has dependency on platform toolset libraries included by Visual Studio 2017 ref: xpbrew/cordova-sqlite-storage#580. Visual Studio 2015 is now supported by brodybits/cordova-sqlite-legacy (permissive license terms, no performance enhancements for Android) and brodybits/cordova-sqlite-evcore-legacy-ext-common-free (GPL or commercial license terms, with performance enhancements for Android). UNTESTED workaround for Visual Studio 2015: it may be possible to support this plugin version on Visual Studio 2015 Update 3 by installing platform toolset v141.)
    • Visual Studio components needed: Universal Windows Platform development, C++ Universal Windows Platform tools. A recent version of Visual Studio 2017 will offer to install any missing feature components.
    • It is NOT possible to use this plugin with the default "Any CPU" target. A specific target CPU type MUST be specified when building an app with this plugin.
    • ARM target CPU for Windows Mobile is no longer supported.
    • The SQLite3-WinRT component in src/windows/SQLite3-WinRT-sync is based on doo/SQLite3-WinRT commit f4b06e6 from 2012, which is missing the asynchronous C++ API improvements. There is no background processing on the Windows platform.
    • Truncation issue with UNICODE \u0000 character (same as \0)
    • INCONSISTENT error code (0) and INCORRECT error message (missing actual error info) in error callbacks ref: xpbrew/cordova-sqlite-storage#539
    • REGEXP is currently not supported on Windows.
    • Not possible to SELECT BLOB column values directly. It is recommended to use built-in HEX function to retrieve BLOB column values, which should work consistently across all platform implementations as well as (WebKit) Web SQL. Non-standard BASE64 function to SELECT BLOB column values in Base64 format is also supported by this plugin version.
    • Windows platform version uses UTF-16le internal database encoding while the other platform versions use UTF-8 internal encoding. (UTF-8 internal encoding is preferred ref: xpbrew/cordova-sqlite-storage#652)
    • Known issue with database names that contain certain US-ASCII punctuation and control characters (see below)
  • The macOS platform version ("osx" platform) is not tested in a release build and should be considered pre-alpha with known issues:
    • cordova prepare osx is needed before building and running from Xcode
    • known issue between cordova-osx and Cordova CLI 10.0.0: apache/cordova-osx#106
  • Android versions supported: 3.0 - 9.0 (API level 11 - 28), depending on Cordova version ref: https://cordova.apache.org/docs/en/latest/guide/platforms/android/
  • iOS versions supported: 8.x / 9.x / 10.x / 11.x / 12.x (see deviations section below for differences in case of WKWebView)
  • FTS3, FTS4, and R-Tree are fully tested and supported for all target platforms in this version branch.
  • Default PRAGMA journal_mode setting (tested):
    • Android use of the androidDatabaseProvider: 'system' setting: persist (pre-8.0) / truncate (Android 8.0, 8.1) / wal (Android Pie)
    • otherwise: delete
  • AUTO-VACUUM is not enabled by default. If no form of VACUUM or PRAGMA auto_vacuum is used then sqlite will automatically reuse deleted data space for new data but the database file will never shrink. For reference: http://www.sqlite.org/pragma.html#pragma_auto_vacuum and xpbrew/cordova-sqlite-storage#646
  • In case of memory issues please use smaller transactions or use the plugin version at litehelpers / Cordova-sqlite-evcore-extbuild-free (GPL or commercial license terms).

Announcements

Highlights

  • Drop-in replacement for HTML5/Web SQL (DRAFT) API: the only change should be to replace the static window.openDatabase() factory call with window.sqlitePlugin.openDatabase(), with parameters as documented below. Known deviations are documented in the deviations section below.
  • Pre-populated openDatabase option (usage described below)
  • Failure-safe nested transactions with batch processing optimizations (according to HTML5/Web SQL (DRAFT) API)
  • Transaction API (based on HTML5/Web SQL (DRAFT) API) is designed for maximum flexiblibility, does not allow any transactions to be left hanging open.
  • As described in this posting:
    • Keeps sqlite database in known, platform specific user data location on all supported platforms (Android/iOS/macOS/Windows), which can be reconfigured on iOS/macOS. Whether or not the database on the iOS platform is synchronized to iCloud depends on the selected database location.
    • No arbitrary size limit. SQLite limits described at: http://www.sqlite.org/limits.html
  • Also validated for multi-page applications by internal test selfTest function.
  • This project is self-contained though with sqlite3 dependencies auto-fetched by npm. There are no dependencies on other plugins such as cordova-plugin-file.
  • Windows platform version uses a customized version of the performant doo / SQLite3-WinRT C++ component.
  • SQLCipher support for Android/iOS/macOS/Windows is available in: brodybits / cordova-sqlcipher-adapter
  • Intellectual property:
    • All source code is tracked to the original author in git, except for code in Android and iOS/macOS createFromResource functions for pre-populated databases which is marked as based on various sources.
    • Major authors are tracked in AUTHORS.md.
    • License of each component is tracked in LICENSE.md.
    • History of this project is also described in HISTORY.md.

TIP: It is possible to migrate from Cordova to a pure native solution and continue using the data stored by this plugin.

Getting started

Recommended prerequisites

  • Install a recent version of Cordova CLI, create a simple app with no plugins, and run it on the desired target platforms.
  • Add a very simple plugin such as cordova-plugin-dialogs or an echo plugin and get it working. Ideally you should be able to handle a callback with some data coming from a prompt.

These prereqisites are very well documented in a number of excellent resources including:

More resources can be found by https://www.google.com/search?q=cordova+tutorial. There are even some tutorials available on YouTube as well.

In addition, this guide assumes a basic knowledge of some key JavaScript concepts such as variables, function calls, and callback functions. There is an excellent explanation of JavaScript callbacks at http://cwbuecheler.com/web/tutorials/2013/javascript-callbacks/.

MAJOR TIPS: As described in the Installing section:

  • In case of extra-old Cordova CLI pre-7.0, it is recommended to use the --save flag when installing plugins to add them to config.xml / package.json. (This is automatic starting with Cordova CLI 7.0.)
  • Assuming that all plugins are added to config.xml or package.json, there is no need to commit the plugins subdirectory tree into the source repository.
  • In general it is not recommended to commit the platforms subdirectory tree into the source repository.

NOTICE: This plugin is only supported with the Cordova CLI. This plugin is not supported with other Cordova/PhoneGap systems such as PhoneGap CLI, PhoneGap Build, Plugman, Intel XDK, Webstorm, etc.

Windows platform notes

Use of this plugin on the Windows platform is not always straightforward, due to the need to build the internal SQLite3 C++ library. The following tips are recommended for getting started with Windows:

  • First start to build and run an app on another platform such as Android or iOS with this plugin.
  • Try working with a very simple app using simpler plugins such as cordova-plugin-dialogs and possibly cordova-plugin-file on the Windows platform.
  • Read through the Windows platform usage subsection (under the Installing section).
  • Then try adding this plugin to a very simple app such as brodybits / cordova-sqlite-test-app and running the Windows project in the Visual Studio GUI with a specific target CPU selected. WARNING: It is not possible to use this plugin with the "Any CPU" target.

Quick installation

Use the following command to install this plugin version from the Cordova CLI:

cordova plugin add cordova-sqlite-ext # --save *recommended* for Coredova pre-7.0

Add any desired platform(s) if not already present, for example:

cordova platform add android

OPTIONAL: prepare before building (MANDATORY for cordova-ios older than 4.3.0 (Cordova CLI 6.4.0))

cordova prepare

or to prepare for a single platform, Android for example:

cordova prepare android

Please see the Installing section for more details.

NOTE: The new brodybits / cordova-sqlite-test-app project includes the echo test, self test, and string test described below along with some more sample functions.

Self test

Try the following programs to verify successful installation and operation:

Echo test - verify successful installation and build:

document.addEventListener('deviceready', function() {
  window.sqlitePlugin.echoTest(function() {
    console.log('ECHO test OK');
  });
});

Self test - automatically verify basic database access operations including opening a database; basic CRUD operations (create data in a table, read the data from the table, update the data, and delete the data); close and delete the database:

document.addEventListener('deviceready', function() {
  window.sqlitePlugin.selfTest(function() {
    console.log('SELF test OK');
  });
});

NOTE: It may be easier to use a JavaScript or native alert function call along with (or instead of) console.log to verify that the installation passes both tests. Same for the SQL string test variations below. (Note that the Windows platform does not support the standard alert function, please use cordova-plugin-dialogs instead.)

SQL string test

This test verifies that you can open a database, execute a basic SQL statement, and get the results (should be TEST STRING):

document.addEventListener('deviceready', function() {
  var db = window.sqlitePlugin.openDatabase({name: 'test.db', location: 'default'});
  db.transaction(function(tr) {
    tr.executeSql("SELECT upper('Test string') AS upperString", [], function(tr, rs) {
      console.log('Got upperString result: ' + rs.rows.item(0).upperString);
    });
  });
});

Here is a variation that uses a SQL parameter instead of a string literal:

document.addEventListener('deviceready', function() {
  var db = window.sqlitePlugin.openDatabase({name: 'test.db', location: 'default'});
  db.transaction(function(tr) {
    tr.executeSql('SELECT upper(?) AS upperString', ['Test string'], function(tr, rs) {
      console.log('Got upperString result: ' + rs.rows.item(0).upperString);
    });
  });
});

Moving forward

It is recommended to read through the usage and sample sections before building more complex applications. In general it is recommended to start by doing things one step at a time, especially when an application does not work as expected.

The new brodybits / cordova-sqlite-test-app sample is intended to be a boilerplate to reproduce and demonstrate any issues you may have with this plugin. You may also use it as a starting point to build a new app.

In case you get stuck with something please read through the support section and follow the instructions before raising an issue. Professional support is also available by contacting: [email protected]

Plugin usage examples and tutorials

Simple example:

Tutorials:

PITFALL WARNING: A number of tutorials show up in search results that use Web SQL database instead of this plugin.

WANTED: simple, working CRUD tutorial sample ref: xpbrew/cordova-sqlite-storage#795

SQLite resources

Some other Cordova resources

Some apps using this plugin

Security

Security of sensitive data

According to Web SQL Database API 7.2 Sensitivity of data:

User agents should treat persistently stored data as potentially sensitive; it's quite possible for e-mails, calendar appointments, health records, or other confidential documents to be stored in this mechanism.

To this end, user agents should ensure that when deleting data, it is promptly deleted from the underlying storage.

Unfortunately this plugin will not actually overwrite the deleted content unless the secure_delete PRAGMA is used.

SQL injection

As "strongly recommended" by Web SQL Database API 8.5 SQL injection:

Authors are strongly recommended to make use of the ? placeholder feature of the executeSql() method, and to never construct SQL statements on the fly.

Avoiding data loss

  • Double-check that the application code follows the documented API for SQL statements, parameter values, success callbacks, and error callbacks.
  • For standard Web SQL transactions include a transaction error callback with the proper logic that indicates to the user if data cannot be stored for any reason. In case of individual SQL error handlers be sure to indicate to the user if there is any issue with storing data.
  • For single statement and batch transactions include an error callback with logic that indicates to the user if data cannot be stored for any reason.

Deviations

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.
  • Known issues with handling of certain ASCII/UNICODE characters as described below.
  • It is possible to request a SQL statement list such as "SELECT 1; SELECT 2" within a single SQL statement string, however the plugin will only execute the first statement and silently ignore the others ref: xpbrew/cordova-sqlite-storage#551
  • It is possible to insert multiple rows like: transaction.executeSql('INSERT INTO MyTable VALUES (?,?),(?,?)', ['Alice', 101, 'Betty', 102]); which was not supported by SQLite 3.6.19 as referenced by Web SQL (DRAFT) API section 5. The iOS WebKit Web SQL implementation seems to support this as well.
  • Unlike the HTML5/Web SQL (DRAFT) API this plugin handles executeSql calls with too few parameters without error reporting. In case of too many parameters this plugin reports error code 0 (SQLError.UNKNOWN_ERR) while Android/iOS (WebKit) Web SQL correctly reports error code 5 (SQLError.SYNTAX_ERR) ref: https://www.w3.org/TR/webdatabase/#dom-sqlexception-code-syntax
  • Positive and negative Infinity SQL parameter argument values are treated like null by this plugin on Android and iOS ref: xpbrew/cordova-sqlite-storage#405
  • Positive and negative Infinity result values cause a crash on iOS/macOS cases ref: xpbrew/cordova-sqlite-storage#405
  • Known issue(s) with of certain ASCII/UNICODE characters as described below.
  • Boolean true and false values are handled by converting them to the "true" and "false" TEXT string values, same as WebKit Web SQL on Android and iOS. This does not seem to be 100% correct as discussed in: xpbrew/cordova-sqlite-storage#545
  • A number of uncategorized errors such as CREATE VIRTUAL TABLE USING bogus module are reported with error code 5 (SQLError.SYNTAX_ERR) on Android/iOS/macOS by both (WebKit) Web SQL and this plugin.
  • Error is reported with error code of 0 on Windows as well as Android with the androidDatabaseProvider: 'system' setting described below.
  • In case of an issue that causes an API function to throw an exception (Android/iOS WebKit) Web SQL includes includes a code member with value of 0 (SQLError.UNKNOWN_ERR) in the exception while the plugin includes no such code member.
  • This plugin supports some non-standard features as documented below.
  • Results of SELECT with BLOB data such as SELECT LOWER(X'40414243') AS myresult, SELECT X'40414243' AS myresult, or reading data stored by INSERT INTO MyTable VALUES (X'40414243') are not consistent on Android with use of androidDatabaseProvider: 'system' setting or Windows. (These work with Android/iOS WebKit Web SQL and have been supported by SQLite for a number of years.)
  • Whole number parameter argument values such as 42, -101, or 1234567890123 are handled as INTEGER values by this plugin on Android, iOS (default UIWebView), and Windows while they are handled as REAL values by (WebKit) Web SQL and by this plugin on iOS with WKWebView (using cordova-plugin-wkwebview-engine) or macOS ("osx"). This is evident in certain test operations such as SELECT ? as myresult or SELECT TYPEOF(?) as myresult and storage in a field with TEXT affinity.
  • INTEGER, REAL, +/- Infinity, NaN, null, undefined parameter argument values are handled as TEXT string values on Android with use of the androidDatabaseProvider: 'system' setting. (This is evident in certain test operations such as SELECT ? as myresult or SELECT TYPEOF(?) as myresult and storage in a field with TEXT affinity.)
  • In case of invalid transaction callback arguments such as string values the plugin attempts to execute the transaction while (WebKit) Web SQL would throw an exception.
  • The plugin handles invalid SQL arguments array values such as false, true, or a string as if there were no arguments while (WebKit) Web SQL would throw an exception. NOTE: In case of a function in place of the SQL arguments array WebKit Web SQL would report a transaction error while the plugin would simply ignore the function.
  • In case of invalid SQL callback arguments such as string values the plugin may execute the SQL and signal transaction success or failure while (WebKit) Web SQL would throw an exception.
  • In certain cases such as transaction.executeSql(null) or transaction.executeSql(undefined) the plugin throws an exception while (WebKit) Web SQL indicates a transaction failure.
  • In certain cases such as transaction.executeSql() with no arguments (Android/iOS WebKit) Web SQL includes includes a code member with value of 0 (SQLError.UNKNOWN_ERR) in the exception while the plugin includes no such code member.
  • If the SQL arguments are passed in an Array subclass object where the constructor does not point to Array then the SQL arguments are ignored by the plugin.
  • The results data objects are not immutable as specified/implied by Web SQL (DRAFT) API section 4.5.
  • This plugin supports use of numbered parameters (?1, ?2, etc.) as documented in https://www.sqlite.org/c3ref/bind_blob.html, not supported by HTML5/Web SQL (DRAFT) API ref: Web SQL (DRAFT) API section 4.2.
  • In case of UPDATE this plugin reports insertId with the result of sqlite3_last_insert_rowid() (except for Android with androidDatabaseProvider: 'system' setting) while attempt to access insertId on the result set database opened by HTML5/Web SQL (DRAFT) API results in an exception.

Security of deleted data

See Security of sensitive data in the Security section above.

Other differences with WebKit Web SQL implementations

  • FTS3 is not consistently supported by (WebKit) Web SQL on Android/iOS.
  • FTS4 and R-Tree are not consistently supported by (WebKit) Web SQL on Android/iOS or desktop browser.
  • In case of ignored INSERT OR IGNORE statement WebKit Web SQL (Android/iOS) reports insertId with an old INSERT row id value while the plugin reports insertId: undefined.
  • In case of a SQL error handler that does not recover the transaction, WebKit Web SQL (Android/iOS) would incorrectly report error code 0 while the plugin would report the same error code as in the SQL error handler. (In case of an error with no SQL error handler then Android/iOS WebKit Web SQL would report the same error code that would have been reported in the SQL error hander.)
  • In case a transaction function throws an exception, the message and code if present are reported by the plugin but not by (WebKit) Web SQL.
  • SQL error messages are inconsistent on Windows.
  • There are some other differences in the SQL error messages reported by WebKit Web SQL and this plugin.

Known issues

  • The iOS/macOS platform versions do not support certain rapidly repeated open-and-close or open-and-delete test scenarios due to how the implementation handles background processing
  • Non-standard encoding of emojis and other 4-byte UTF-8 characters on Android pre-6.0 with default Android NDK implementation ref: xpbrew/cordova-sqlite-storage#564 (this is not an issue when using the androidDatabaseProvider: 'system' setting)
  • It is possible to request a SQL statement list such as "SELECT 1; SELECT 2" within a single SQL statement string, however the plugin will only execute the first statement and silently ignore the others ref: xpbrew/cordova-sqlite-storage#551
  • Execution of INSERT statement that affects multiple rows (due to SELECT cause or using TRIGGER(s), for example) reports incorrect rowsAffected on Android with use of the androidDatabaseProvider: 'system' setting.
  • 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 (GPL or commercial license terms)
  • Infinity (positive or negative) values are not supported on Android/iOS/macOS due to issues described above including a possible crash on iOS/macOS ref: xpbrew/cordova-sqlite-storage#405
  • A stability issue was reported on the iOS platform version when in use together with SockJS client such as pusher-js at the same time (see xpbrew/cordova-sqlite-storage#196). The workaround is to call sqlite functions and SockJS client functions in separate ticks (using setTimeout with 0 timeout).
  • SQL errors are reported with incorrect & inconsistent error message on Windows - missing actual error info ref: xpbrew/cordova-sqlite-storage#539.
  • Close/delete database bugs described below.
  • When a database is opened and deleted without closing, the iOS/macOS platform version is known to leak resources.
  • It is NOT possible to open multiple databases with the same name but in different locations (iOS/macOS platform version).
  • Incorrect or missing rowsAffected in results for INSERT/UPDATE/DELETE SQL statements with extra semicolon(s) in the beginning for Android in case the androidDatabaseImplementation: 2 (built-in android.database implementation) option is used.

Some additional issues are tracked in open cordova-sqlite-storage bug-general issues and open cordova-sqlite-ext bug-general issues.

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.)
  • Extremely large records are not supported by this plugin. It is recommended to store images and similar binary data in separate files. TBD: specify maximum record. For future consideration: support in a plugin version such as litehelpers / Cordova-sqlite-evcore-extbuild-free (GPL or commercial license terms).
  • This plugin version will not work within a web worker (not properly supported by the Cordova framework). Use within a web worker is supported for Android/iOS/macOS in litehelpers / cordova-sqlite-evmax-ext-workers-legacy-build-free (GPL or special premium commercial license terms).
  • In-memory database db=window.sqlitePlugin.openDatabase({name: ':memory:', ...}) is currently not supported.
  • The Android platform version cannot properly support more than 100 open database files due to the threading model used.
  • REGEXP is currently not supported on Windows.
  • SQL error messages reported by Windows platform version are not consistent with Android/iOS/macOS platform versions.
  • UNICODE \u2028 (line separator) and \u2029 (paragraph separator) characters are currently not supported and known to be broken on iOS, macOS, and Android platform versions due to JSON issues reported in Cordova bug CB-9435 and cordova/cordova-discuss#57. This is fixed with a workaround for iOS/macOS in: litehelpers / Cordova-sqlite-evplus-legacy-free and litehelpers / Cordova-sqlite-evplus-legacy-attach-detach-free (GPL or special commercial license terms) as well as litehelpers / cordova-sqlite-evmax-ext-workers-legacy-build-free (GPL or premium commercial license terms).
  • SELECT BLOB column value type is not supported consistently across all platforms (not supported on Windows). It is recommended to use the built-in HEX function to SELECT BLOB column data in hexadecimal format, working consistently across all platforms. As an alternative: SELECT BLOB in Base64 format is supported by this plugin version, brodybits/cordova-sqlite-ext (permissive license terms) and litehelpers / Cordova-sqlite-evcore-extbuild-free (GPL or commercial license options).
  • Database files with certain multi-byte UTF-8 characters are not tested and not expected to work consistently across all platform implementations.
  • Issues with UNICODE \u0000 character (same as \0):
  • 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.
  • The iOS/macOS platform version uses a thread pool but with only one thread working at a time due to "synchronized" database access.
  • Some large query results may be slow, also due to the JSON implementation.
  • ATTACH to another database file is not supported by this version branch. 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 (GPL or special commercial license terms).
  • UPDATE/DELETE with LIMIT or ORDER BY is not supported.
  • WITH clause is not supported on some older Android platform versions in case the androidDatabaseProvider: 'system' setting 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.
  • Issues have been reported with using this plugin together with Crosswalk for Android, especially on x86_64 CPU (xpbrew/cordova-sqlite-storage#336). Please see xpbrew/cordova-sqlite-storage#336 (comment) for workaround on x64 CPU. In addition it may be helpful to install Crosswalk as a plugin instead of using Crosswalk to create a project that will use this plugin.
  • 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.
  • Does not support named parameters (?NNN/:AAA/@AAAA/$AAAA parameter placeholders as documented in https://www.sqlite.org/lang_expr.html#varparam and https://www.sqlite.org/c3ref/bind_blob.html) ref: xpbrew/cordova-sqlite-storage#717
  • User defined functions not supported, due to problems described in xpbrew/cordova-sqlite-storage#741

Additional limitations are tracked in marked cordova-sqlite-storage doc-todo issues and marked cordova-sqlite-ext doc-todo issues.

Further testing needed

  • Integration with PhoneGap developer app
  • Use within InAppBrowser
  • TODO add some more REGEXP tests
  • Use within an iframe (see xpbrew/cordova-sqlite-storage#368 (comment))
  • Date/time handling
  • Maximum record size supported
  • Actual behavior when using SAVEPOINT(s)
  • R-Tree is not fully tested with Android
  • UNICODE characters not fully tested
  • ORDER BY RANDOM() (ref: xpbrew/cordova-sqlite-storage#334)
  • 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)
  • Handling of invalid transaction and transaction.executeSql arguments
  • Use of database locations on macOS
  • Extremely large and small INTEGER and REAL values ref: xpbrew/cordova-sqlite-storage#627
  • More emojis and other 4-octet UTF-8 characters
  • More database file names with some more control characters and multi-byte UTF-8 characters (including emojis and other 4-byte UTF-8 characters)
  • Use of numbered parameters (?1, ?2, etc.) as documented in https://www.sqlite.org/c3ref/bind_blob.html
  • Use of ?NNN/:AAA/@AAAA/$AAAA parameter placeholders as documented in https://www.sqlite.org/lang_expr.html#varparam and https://www.sqlite.org/c3ref/bind_blob.html) (currently NOT supported by this plugin) ref: xpbrew/cordova-sqlite-storage#717
  • Single-statement and SQL batch transaction calls with invalid arguments (TBD behavior subject to change)
  • Plugin vs (WebKit) Web SQL transaction behavior in case of an error handler which returns various falsy vs truthy values
  • Other open Cordova-sqlite-storage testing issues

Some tips and tricks

  • In case of issues with code that follows the asynchronous Web SQL transaction API, it is possible to test with a test database using window.openDatabase for comparison with (WebKit) Web SQL.
  • 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.

Pitfalls

Extremely common pitfall(s)

IMPORTANT: A number of tutorials and samples in search results suffer from the following pitfall:

  • If a database is opened using the standard window.openDatabase call it will not have any of the benefits of this plugin and features such as the sqlBatch call would not be available.

Common update pitfall(s)

  • Updates such as database schema changes, migrations from use of Web SQL, migration between data storage formats must be handled with extreme care. It is generally extremely difficult or impossible to predict when users will install application updates. Upgrades from old database schemas and formats must be supported for a very long time.

Other common pitfall(s)

  • 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 (DRAFT) 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. If no form of VACUUM or PRAGMA auto_vacuum is used then sqlite will automatically reuse deleted data space for new data but the database file will never shrink. For reference: http://www.sqlite.org/pragma.html#pragma_auto_vacuum and xpbrew/cordova-sqlite-storage#646
  • Transactions on a database are run sequentially. A large transaction could block smaller transactions requested afterwards.

Some weird pitfall(s)

  • intent whitelist: blocked intent such as external URL intent may cause this and perhaps certain Cordova plugin(s) to misbehave (see xpbrew/cordova-sqlite-storage#396)

Angular/ngCordova/Ionic-related pitfalls

Windows platform pitfalls

  • This plugin does not work with the default "Any CPU" target. A specific, valid CPU target platform must be specified.
  • It is not allowed to change the app ID in the Windows platform project. As described in the Windows platform usage of the Installing section a Windows-specific app ID may be declared using the windows-identity-name attribute or "WindowsStoreIdentityName" setting.
  • A problem locating SQLite3.md generally means that there was a problem building the C++ library.
  • Visual Studio 2015 is no longer supported by this plugin version. Visual Studio 2015 is now supported by brodybits/cordova-sqlite-legacy (for Windows 8.1, Windows Phone 8.1, and Windows 10 builds).

General Cordova pitfalls

Documented in: brodybits / Avoiding-some-Cordova-pitfalls

General SQLite pitfalls

From https://www.sqlite.org/datatype3.html#section_1:

SQLite uses a more general dynamic type system.

This is generally nice to have, especially in conjunction with a dynamically typed language such as JavaScript. Here are some major SQLite data typing principles:

However there are some possible gotchas:

  1. From https://www.sqlite.org/datatype3.html#section_3_2:

Note that a declared type of "FLOATING POINT" would give INTEGER affinity, not REAL affinity, due to the "INT" at the end of "POINT". And the declared type of "STRING" has an affinity of NUMERIC, not TEXT.

  1. From ibid: a column declared as "DATETIME" has NUMERIC affinity, which gives no hint whether an INTEGER Unix time value, a REAL Julian time value, or possibly even a TEXT ISO8601 date/time string may be stored (further refs: https://www.sqlite.org/datatype3.html#section_2_2, https://www.sqlite.org/datatype3.html#section_3)

From https://groups.google.com/forum/#!topic/phonegap/za7z51_fKRw, as discussed in xpbrew/cordova-sqlite-storage#546: it was discovered that are some more points of possible confusion with date/time. For example, there is also a datetime function that returns date/time in TEXT string format. This should be considered a case of "DATETIME" overloading since SQLite is not case sensitive. This could really become confusing if different programmers or functions consider date/time to be stored in different ways.

FUTURE TBD: Proper date/time handling will be further tested and documented at some point.

Major TODOs

For future considertion

Alternatives

Comparison of sqlite plugin versions

  • xpbrew/cordova-sqlite-storage - core plugin version for Android/iOS/macOS/Windows (permissive license terms)
  • brodybits/cordova-sqlite-ext - plugin version with REGEXP (Android/iOS/macOS), SELECT BLOB in Base64 format (all platforms Android/iOS/macOS/Windows), and pre-populated databases (all platforms Android/iOS/macOS/Windows). Permissive license terms.
  • brodybits/cordova-sqlite-legacy - support for Windows 8.1/Windows Phone 8.1 along with Android/iOS/macOS/Windows 10, with support for REGEXP (Android/iOS/macOS), SELECT BLOB in Base64 format (all platforms Android/iOS/macOS/Windows), and pre-populated databases (all platforms Android/iOS/macOS/Windows). Limited updates. Permissive license terms.
  • brodybits/cordova-sqlite-legacy-build-support - maintenance of WP8 platform version along with Windows 8.1/Windows Phone 8.1 and the other supported platforms Android/iOS/macOS/Windows 10; limited support for PhoneGap CLI/PhoneGap Build/plugman/Intel XDK; limited testing; limited updates. Permissive license terms.
  • brodybits/cordova-sqlcipher-adapter - supports SQLCipher for Android/iOS/macOS/Windows
  • litehelpers / Cordova-sqlite-evcore-extbuild-free - Enhancements for Android: JSON and SQL statement handling implemented in C, supports larger transactions and handles large SQL batches in less than half the time as this plugin version. Supports arbitrary database location on Android. Support for build environments such as PhoneGap Build and Intel XDK. Also includes REGEXP (Android/iOS/macOS) and SELECT BLOB in Base64 format (all platforms Android/iOS/macOS/Windows). GPL or commercial license terms.
  • litehelpers / cordova-sqlite-evplus-ext-legacy-build-free - internal memory improvements to support larger transactions (Android/iOS) and fix to support all Unicode characters (iOS). (GPL or special commercial license terms).
  • litehelpers / Cordova-sqlite-evplus-legacy-attach-detach-free - plugin version with support for ATTACH, includes internal memory improvements to support larger transactions (Android/iOS) and fix to support all Unicode characters (GPL or special commercial license terms).
  • litehelpers / cordova-sqlite-evmax-ext-workers-legacy-build-free - plugin version with support for web workers, includes internal memory improvements to support larger transactions (Android/iOS) and fix to support all Unicode characters (iOS). (GPL or special premium commercial license terms).
  • Adaptation for React Native Android and iOS: andpor / react-native-sqlite-storage (permissive license terms)
  • Original plugin version for iOS (with a non-standard, outdated transaction API): davibe / Phonegap-SQLitePlugin (permissive license terms)

Other SQLite access projects

Alternative storage 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 a database (named ___$$$___litehelpers___$$$___test___$$$___.db), execute the CRUD (create, read, update, and delete) operations, and clean it up properly:

window.sqlitePlugin.selfTest(successCallback, errorCallback);

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

General

  • Drop-in replacement for HTML5/Web SQL (DRAFT) 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 described throughout this document. Reports of any other deviations would be appreciated.
  • Single-page application design is recommended.
  • In case of a multi-page application the JavaScript used by each page must use sqlitePlugin.openDatabase to open the database access handle object before it can access the data.

NOTE: If a sqlite statement in a transaction fails with an error, the error handler must return false in order to recover the transaction. This is correct according to the HTML5/Web SQL (DRAFT) API standard. This is different from the WebKit implementation of Web SQL in Android and iOS which recovers the transaction if a sql error hander returns a truthy value.

See the Sample section for a sample with detailed explanations.

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 different from the old default location used until March 2016 and would break an upgrade for an app that was using the old default setting (location: 0, same as using iosDatabaseLocation: 'Documents') on iOS. The recommended solution is to continue to open the database from the same location, using iosDatabaseLocation: 'Documents'.

WARNING 2: As described above: by default this plugin uses a non-standard https://github.com/brodybits/android-sqlite-native-ndk-connector implementation on Android. In case an application access the same database using multiple plugins there is a risk of data corruption ref: storesafe/cordova-sqlite-storage#626) as described in http://ericsink.com/entries/multiple_sqlite_problem.html and https://www.sqlite.org/howtocorrupt.html. The workaround is to use the androidDatabaseProvider: 'system' setting as described in the Android sqlite implementation section below.

To specify a different location (affects iOS/macOS only):

var db = window.sqlitePlugin.openDatabase({name: 'my.db', iosDatabaseLocation: 'Library'}, successcb, errorcb);

where the iosDatabaseLocation option may be set to one of the following choices:

  • default: Library/LocalDatabase subdirectory - NOT visible to iTunes and NOT backed up by 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.

DEPRECATED ALTERNATIVE to be removed in an upcoming release:

  • var db = window.sqlitePlugin.openDatabase({name: "my.db", location: 1}, successcb, errorcb);

with the location option set to one the following choices (affects iOS only):

  • 0 (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.

DATABASE NAME NOTES:

  • Database file names with slash (/) character(s) are not supported and not expected to work on any platform.
  • Database file names with ASCII control characters such as tab, vertical tab, carriage return, line feed, form feed, and backspace are NOT RECOMMENDED, with known issue on Windows.
  • Some other ASCII characters NOT RECOMMENDED, with known issue on Windows: * < > ? \ " |
  • Database file names with multi-byte UTF-8 characters are currently not recommended due to very limited testing.

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

Pre-populated database(s)

Put the database file in the www directory and open the database as follows (both database location and createFromLocation items are required):

var db = window.sqlitePlugin.openDatabase({name: "my.db", location: 'default', createFromLocation: 1});

IMPORTANT NOTES:

  • Put the pre-populated database file in the www subdirectory. (This should work well the Cordova CLI.) No matter which child folder your HTML file is in, the database MUST sit in the 'www' subdirectory.
  • The pre-populated database file name must match exactly the file name given in openDatabase. This plugin does not use an automatic extension.
  • The pre-populated database file is ignored if the database file with the same name already exists in your database file location.

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:

See plugin usage examples section above

Other alternative solutions:

iCloud backup notes

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)

Android database provider

By default, this plugin uses https://github.com/brodybits/android-sqlite-native-ndk-connector, which is lightweight and should be more efficient than the Android system database provider. To use the built-in Android system database provider implementation instead:

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

(Use of the androidDatabaseImplementation: 2 setting which is now replaced by androidDatabaseProvider: 'system' is now deprecated and may be removed in the near future.)

IMPORTANT:

  • As described above: by default this plugin uses a non-standard android-sqlite-native-ndk-connector implementation on Android. In case an application access the same database using multiple plugins there is a risk of data corruption ref: xpbrew/cordova-sqlite-storage#626) as described in http://ericsink.com/entries/multiple_sqlite_problem.html and https://www.sqlite.org/howtocorrupt.html. The workaround is to use the androidDatabaseProvider: 'system' setting as described here.
  • In case of the androidDatabaseProvider: 'system' setting, xpbrew/cordova-sqlite-storage#193 reported (as observed by a number of app developers in the past) that in certain Android versions, if the app is stopped or aborted without closing the database then there is an unexpected database lock and the data that was inserted is lost. The workaround is described below.

Workaround for Android db locking issue

xpbrew/cordova-sqlite-storage#193 reported (as observed by a number of app developers in the past) that when using the Android system database provider (using the androidDatabaseProvider: 'system' setting) on certain Android versions and if the app is stopped or aborted without closing the database then:

  • (sometimes) there is an unexpected database lock
  • the data that was inserted is lost.

The cause of this issue remains unknown. Of interest: android / platform_external_sqlite commit d4f30d0d15 which references and includes the sqlite commit at: http://www.sqlite.org/src/info/6c4c2b7dba

This is not an issue when the default android-sqlite-native-ndk-connector database implementation is used, which is the case when no androidDatabaseProvider or androidDatabaseImplementation setting is used.

There is an optional workaround that simply closes and reopens the database file at the end of every transaction that is committed. The workaround is enabled by opening the database with options as follows:

var db = window.sqlitePlugin.openDatabase({
  name: 'my.db',
  location: 'default',
  androidDatabaseProvider: 'system'
  androidLockWorkaround: 1
});

IMPORTANT NOTE: This workaround is only applied when using db.sqlBatch or db.transaction(), not applied when running executeSql() on the database object.

SQL transactions

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

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

NOTE: Transaction requests are kept in one queue per database and executed in sequential order, according to the HTML5/Web SQL (DRAFT) API.

WARNING: It is possible to request a SQL statement list such as "SELECT 1; SELECT 2" within a single SQL statement string, however the plugin will only execute the first statement and silently ignore the others. This could result in data loss if such a SQL statement list with any INSERT or UPDATE statement(s) are included. For reference: xpbrew/cordova-sqlite-storage#551

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

or using numbered parameters as documented in https://www.sqlite.org/c3ref/bind_blob.html:

db.executeSql('INSERT INTO MyTable VALUES (?1)', ['test-value'], function (resultSet) {
  console.log('resultSet.insertId: ' + resultSet.insertId);
  console.log('resultSet.rowsAffected: ' + resultSet.rowsAffected);
}, function(error) {
  console.log('SELECT error: ' + error.message);
});

Sample with SELECT:

db.executeSql("SELECT LENGTH('tenletters') AS stringlength", [], function (resultSet) {
  console.log('got stringlength: ' + resultSet.rows.item(0).stringlength);
}, function(error) {
  console.log('SELECT error: ' + error.message);
});

NOTE/minor bug: The object returned by resultSet.rows.item(rowNumber) is not immutable. In addition, multiple calls to resultSet.rows.item(rowNumber) with the same rowNumber on the same resultSet object return the same object. For example, the following code will show Second uppertext result: ANOTHER:

db.executeSql("SELECT UPPER('First') AS uppertext", [], function (resultSet) {
  var obj1 = resultSet.rows.item(0);
  obj1.uppertext = 'ANOTHER';
  console.log('Second uppertext result: ' + resultSet.rows.item(0).uppertext);
  console.log('SELECT error: ' + error.message);
});

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

or using numbered parameters as documented in https://www.sqlite.org/c3ref/bind_blob.html:

db.sqlBatch([
  'CREATE TABLE MyTable IF NOT EXISTS (name STRING, balance INTEGER)',
  [ 'INSERT INTO MyTable VALUES (?1,?2)', ['Alice', 100] ],
  [ 'INSERT INTO MyTable VALUES (?1,?2)', ['Betty', 200] ],
], function() {
  console.log('MyTable is now populated.');
}, function(error) {
  console.log('Populate table error: ' + error.message);
});

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

Standard asynchronous transactions

DRAFT standard asynchronous transactions follow the HTML5/Web SQL (DRAFT) API which is very well documented and uses BEGIN and COMMIT or ROLLBACK to keep the transactions failure-safe. Here is a simple example:

db.transaction(function(tx) {
  tx.executeSql('DROP TABLE IF EXISTS MyTable');
  tx.executeSql('CREATE TABLE MyTable (SampleColumn)');
  tx.executeSql('INSERT INTO MyTable VALUES (?)', ['test-value'], function(tx, resultSet) {
    console.log('resultSet.insertId: ' + resultSet.insertId);
    console.log('resultSet.rowsAffected: ' + resultSet.rowsAffected);
  }, function(tx, error) {
    console.log('INSERT error: ' + error.message);
  });
}, function(error) {
  console.log('transaction error: ' + error.message);
}, function() {
  console.log('transaction ok');
});

or using numbered parameters as documented in https://www.sqlite.org/c3ref/bind_blob.html:

db.transaction(function(tx) {
  tx.executeSql('DROP TABLE IF EXISTS MyTable');
  tx.executeSql('CREATE TABLE MyTable (SampleColumn)');
  tx.executeSql('INSERT INTO MyTable VALUES (?1)', ['test-value'], function(tx, resultSet) {
    console.log('resultSet.insertId: ' + resultSet.insertId);
    console.log('resultSet.rowsAffected: ' + resultSet.rowsAffected);
  }, function(tx, error) {
    console.log('INSERT error: ' + error.message);
  });
}, function(error) {
  console.log('transaction error: ' + error.message);
}, function() {
  console.log('transaction ok');
});

In case of a read-only transaction, it is possible to use readTransaction which will not use BEGIN, COMMIT, or ROLLBACK:

db.readTransaction(function(tx) {
  tx.executeSql("SELECT UPPER('Some US-ASCII text') AS uppertext", [], function(tx, resultSet) {
    console.log("resultSet.rows.item(0).uppertext: " + resultSet.rows.item(0).uppertext);
  }, function(tx, error) {
    console.log('SELECT error: ' + error.message);
  });
}, function(error) {
  console.log('transaction error: ' + error.message);
}, function() {
  console.log('transaction ok');
});

WARNING: It is NOT allowed to execute sql statements on a transaction after it has finished. Here is an example from the Populating Cordova SQLite storage with the JQuery API post at http://www.brodybits.com/cordova/sqlite/api/jquery/2015/10/26/populating-cordova-sqlite-storage-with-the-jquery-api.html:

  // BROKEN SAMPLE:
  var db = window.sqlitePlugin.openDatabase({name: 'my.db', location: 'default'});
  db.executeSql("DROP TABLE IF EXISTS tt");
  db.executeSql("CREATE TABLE tt (data)");

  db.transaction(function(tx) {
    $.ajax({
      url: 'https://api.github.com/users/litehelpers/repos',
      dataType: 'json',
      success: function(res) {
        console.log('Got AJAX response: ' + JSON.stringify(res));
        $.each(res, function(i, item) {
          console.log('REPO NAME: ' + item.name);
          tx.executeSql("INSERT INTO tt values (?)", JSON.stringify(item.name));
        });
      }
    });
  }, function(e) {
    console.log('Transaction error: ' + e.message);
  }, function() {
    // Check results:
    db.executeSql('SELECT COUNT(*) FROM tt', [], function(res) {
      console.log('Check SELECT result: ' + JSON.stringify(res.rows.item(0)));
    });
  });

You can find more details and a step-by-step description how to do this right in the Populating Cordova SQLite storage with the JQuery API post at: http://www.brodybits.com/cordova/sqlite/api/jquery/2015/10/26/populating-cordova-sqlite-storage-with-the-jquery-api.html

NOTE/minor bug: Just like the single-statement transaction described above, the object returned by resultSet.rows.item(rowNumber) is not immutable. In addition, multiple calls to resultSet.rows.item(rowNumber) with the same rowNumber on the same resultSet object return the same object. For example, the following code will show Second uppertext result: ANOTHER:

db.readTransaction(function(tx) {
  tx.executeSql("SELECT UPPER('First') AS uppertext", [], function(tx, resultSet) {
    var obj1 = resultSet.rows.item(0);
    obj1.uppertext = 'ANOTHER';
    console.log('Second uppertext result: ' + resultSet.rows.item(0).uppertext);
    console.log('SELECT error: ' + error.message);
  });
});

FUTURE TBD: It should be possible to get a row result object using resultSet.rows[rowNumber], also in case of a single-statement transaction. This is non-standard but is supported by the Chrome desktop browser.

SELECT BLOB data as BASE64

db.readTransaction(function(tx) {
  tx.executeSql("SELECT BASE64(data) AS base64_data FROM MyTable", [], function(tx, resultSet) {
    console.log('BLOB data (base64): ' + resultSet.rows.item(0).base64_data);
  });
});

NOTICE: This is not supported in case a database is opened with the androidDatabaseImplementation: 2 option.

INSERT BLOB data from BASE64 string value

db.transaction(function(tx) {
  tx.executeSql("INSERT INTO MyTable (data) VALUES (BLOBFROMBASE64(?))", ["AQID"], function(tx, resultSet) {
    console.log("insertId: " + resultSet.insertId + " -- probably 1");
    console.log("rowsAffected: " + resultSet.rowsAffected + " -- should be 1");
  });
});

Background processing

The threading model depends on which platform version is used:

  • For Android, one background thread per db;
  • for iOS/macOS, 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. TODO: All pending transactions should be errored whenever a database connection is closed.

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

  • 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/macOS only)

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

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

Ionic Native with browser support

Ionic 3

Ionic 2

Tutorials with Ionic 2:

Sample on Ionic 2:

Ionic 1

Tutorial with Ionic 1: https://blog.nraboy.com/2014/11/use-sqlite-instead-local-storage-ionic-framework/

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

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

Other resource (apparently for Ionic 1): https://www.packtpub.com/books/content/how-use-sqlite-ionic-store-data

NOTE: Some Ionic and other Angular pitfalls are described above.

Installing

Easy installation with Cordova CLI tool

cordova plugin add cordova-sqlite-ext # --save *recommended* on Cordova pre-7.0

Additional Cordova CLI NOTES:

  • As stated above:
    • In case of Cordova CLI pre-7.0 it is recommended to add plugins including standard plugins such as cordova-plugin-whitelist with the --save flag to track these in config.xml (automatically saved in config.xml / package.json starting with Cordova CLI 7.0).
    • In general there is no need to keep the Cordova platforms subdirectory tree in source code control (such as git). In case ALL plugins are tracked in config.xml or package.json (automatic starting with Cordova CLI 7.0, --save flag needed for Cordova CLI pre-7.0) then there is no need to keep the plugins subdirectory tree in source code control either.
  • It may be necessary to use cordova prepare in case of cordova-ios older than 4.3.0 (Cordova CLI 6.4.0) or cordova-osx.
  • In case of problems with building and running it is recommended to try again after cordova prepare.
  • 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

or more drastically:

rm -rf platforms
cordova platform add ios

Plugin installation sources

Windows platform usage

This plugin can be challenging to use on Windows since it includes a native SQLite3 library that is built as a part of the Cordova app. Here are some requirements:

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

Free 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.

Professional support

Professional support is available by contacting: [email protected]

For more information: https://xpbrew.consulting

Before seeking 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:

Issues with AJAX

General: As documented above with a negative example the application must wait for the AJAX query to finish before starting a transaction and adding the data elements.

In case of issues it is recommended to rework the reproduction program insert the data from a JavaScript object after a delay. There is already a test function for this in brodybits / cordova-sqlite-test-app.

FUTURE TBD examples

Test program to seek help

If you continue to see the issue: please make the simplest test program possible based on brodybits / cordova-sqlite-test-app to demonstrate the issue with the following characteristics:

  • it 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.

Before asking for help with a pre-populated database

This plugin has been tested and successfully used with pre-populated databases. But you have to do it very carefully. If you are having any trouble, please start with a new, clean Cordova project, add this plugin, use the sqlite3 tool to make a small test database, and try to read it.

What will be supported for free

It is recommended to make a small, self-contained test program based on brodybits / cordova-sqlite-test-app that can demonstrate your problem and post it. Please do not use any other plugins or frameworks than are absolutely necessary to demonstrate your problem.

In case of a problem with a pre-populated database, please post your entire project.

What is NOT supported for free

  • Debugging, optimization, and other help with application code.

What information is needed for help

Please include the following:

  • Which platform(s) Android/iOS/macOS/Windows 10
  • Clear description of the issue
  • A small, complete, self-contained program that demonstrates the problem, preferably as a Github project, based on brodybits / cordova-sqlite-test-app. ZIP/TGZ/BZ2 archive available from a public link is OK. No RAR or other such formats please.
  • In case of a Windows build problem please capture the entire compiler output.

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 request help

Please include the information described above otherwise.

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

GENERAL: The adapters described here are community maintained.

Lawnchair Adapter

PouchDB

Adapters wanted

  • IndexedDBShim adapter (possibly based on IndexedDBShim)

Sample

Contributed by @Mikejo5000 (Mike Jones) from Microsoft.

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

Source tree

  • SQLitePlugin.coffee.md: platform-independent (Literate CoffeeScript, can be compiled with a recent CoffeeScript (1.x) compiler)
  • www: platform-independent Javascript as generated from SQLitePlugin.coffee.md using coffeescript@1 (and committed!)
  • src: platform-specific source code
  • node_modules: placeholder for external dependencies
  • scripts: installation hook script to fetch the external dependencies via npm
  • spec: test suite using Jasmine (2.5.2), also passes on (WebKit) Web SQL on Android, iOS, Safari desktop browser, and Chrome desktop browser
  • tests: very simple Jasmine test suite that is run on Circle CI (Android platform) and Travis CI (iOS platform) (used as a placeholder)

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

[email protected]

cordova-sqlite-ext's People

Contributors

aarononeal avatar brodybits avatar craig-at-rsg avatar davibe avatar dwinterbourne avatar ef4 avatar gillardo avatar gulian avatar j3k0 avatar joenoon avatar kakysha avatar lcsanchez avatar marcucio avatar mineshaftgap avatar nadyaa avatar nleclerc avatar nolanlawson avatar nourshamrok avatar ollide avatar omjokine avatar rafaelbeckel avatar rahmadid avatar ste4net avatar steipete avatar steveoh avatar svranch avatar taybin avatar vjrantal avatar vldmrrr avatar vojto avatar

Stargazers

avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar

Watchers

avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar

Forkers

sxagan odeann vizualiiz stevensotelo fouadhub jworsman javanjoseph trevorpowell prashanth889 k1dbl4ck britehousemobile styleflasher zuanoc konectech ruuti svranch securecloud-biz nullvoids denisvedin mahongtao jessisena cata86 ewkonzo t1geomatika be-ndee kingw0 shady786 persfrancobe jpmguides karthikajjan cbforks rosterbuster naikan vegetablesalad muhammadandikakurniawan lapisit rsalt thomasvanhorde maximbelov viermorgen njc-gov pinkbike netcareltd macchiosilver parmantolab mobile-tools shafiramaki lateph faustopala sbmathews israelhikingmap joensen c-christensen itnode

cordova-sqlite-ext's Issues

Run sql script

Its possible to run a SQL script? like:

script.sql
BEGIN;
CREATE TABLE "teste"(
"teste_id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
"nome" VARCHAR(50) NOT NULL
);

CREATE TABLE "version_app"(
"version" INTEGER
);

INSERT INTO VERSION_APP (version) values (1);
COMMIT;

Thanks to advance

When I query sqlite multithread,android app crashed

when query sqlite multithread, (javascript event trigger asynchronized, I didn't try to control it in javascript, then it crashed sometimes, and more query times happened, crash times increase.

crash information:

11-25 22:04:18.145     517-1017/? A/libc﹕ Fatal signal 11 (SIGSEGV), code 1, fault addr 0xa4bae49a in tid 1017 (pool-1-thread-5)
11-25 22:04:18.248      329-329/? I/DEBUG﹕ Build fingerprint: 'AUTOID/msm8916_d510p/msm8916_d510p:5.1.1/V1.1.2/V1.1.2:user/dev-keys'
11-25 22:04:18.249      329-329/? I/DEBUG﹕ Revision: '0' 
11-25 22:04:18.249      329-329/? I/DEBUG﹕ ABI: 'arm'
11-25 22:04:18.249      329-329/? I/DEBUG﹕ pid: 517, tid: 1017, name: pool-1-thread-5  >>> com.ionicframework.electriclab474915 <<<
11-25 22:04:18.249      329-329/? I/DEBUG﹕ signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0xa4bae49a
11-25 22:04:18.271      329-329/? I/DEBUG﹕ r0 a4bae482  r1 e17c06b4  r2 00000000  r3 00000001
11-25 22:04:18.271      329-329/? I/DEBUG﹕ r4 ab8a6540  r5 e17c06b4  r6 ab8a6b40  r7 ab8a65c0
11-25 22:04:18.271      329-329/? I/DEBUG﹕ r8 0000001b  r9 000002c9  sl 3b9aca00  fp e17c07d4
11-25 22:04:18.271      329-329/? I/DEBUG﹕ ip 00000000  sp e17c06b0  lr e54baaa9  pc e54ba9ec  cpsr 200f0030
11-25 22:04:18.272      329-329/? I/DEBUG﹕ backtrace:
11-25 22:04:18.272      329-329/? I/DEBUG﹕ #00 pc 000179ec  /data/app/com.ionicframework.electriclab474915-2/lib/arm/libsqlc-native-driver.so
11-25 22:04:18.272      329-329/? I/DEBUG﹕ #01 pc 00017aa5  /data/app/com.ionicframework.electriclab474915-2/lib/arm/libsqlc-native-driver.so
11-25 22:04:18.272      329-329/? I/DEBUG﹕ #02 pc 0002e5f3  /data/app/com.ionicframework.electriclab474915-2/lib/arm/libsqlc-native-driver.so
11-25 22:04:18.272      329-329/? I/DEBUG﹕ #03 pc 00055a8f  /data/app/com.ionicframework.electriclab474915-2/lib/arm/libsqlc-native-driver.so
11-25 22:04:18.272      329-329/? I/DEBUG﹕ #04 pc 00057901  /data/app/com.ionicframework.electriclab474915-2/lib/arm/libsqlc-native-driver.so
11-25 22:04:18.272      329-329/? I/DEBUG﹕ #05 pc 00057b71  /data/app/com.ionicframework.electriclab474915-2/lib/arm/libsqlc-native-driver.so`

So, I add synchronized keyword before executeSQLiteStatement method in SQLiteConnectorDatabase.java, the app doesn't crash now... However, queries become very very slow....

Any suggestions? Thanks.

Please support target browser

cordova supports browser as a platform so that we can develop and test on a browser. I think that's a good approach to test our code. But cordova-sqlite-ext doesn't work on browser. Please add the support.

SQLite plugin dont work

I am trying to create a database and tables , but I want to do after the request to the server to be successful, I do not want to create it when you open the application , as I have seen they do in most examples of internet

I would also like to know whether to implement Project CrossWalk in my project , this causes or could be causing some sort of conflict with the SQLite plugin or with others.

Development Information

  • Crosswalk Plugin
  • Brackets editor
  • Windows 10
  • Cordova Cli 6.0.0
  • Ionic Cli 1.7.14
  • Node Version 5.5.0

This is my code

angular.module('unicesarApp', ['ionic', 'historialApp', 'ngCordova']) .controller('formulario', formulario) .service('obtenerDatos', obtenerDatos) .config(config);

 `formulario.$inject = ['$scope', 'obtenerDatos', '$state', '$timeout', '$cordovaSQLite'];

 function formulario($scope, obtenerDatos, $state, $timeout, $cordovaSQLite){

$scope.login = function(){


var datos, datosRespuesta;

datos = {
    Usuario: $scope.usuariotxt,
    Password: $scope.passwordtxt
};

if(datos.Usuario == undefined && datos.Password == undefined){

    $scope.respuesta = "Los campos estan vacios";

}else{                

    $scope.respuesta = "Solicitando informacion";

    obtenerDatos.Autenticacion(datos).then(function(response) {

      if(response.data) {

        datosRespuesta = response.data;

          if (datosRespuesta === "Usuario no registrado" || 
              datosRespuesta === "Contraseña incorrecta") {

                  $scope.respuesta = datosRespuesta;                              

          } else {        

                if (datosRespuesta.estudiante){

                    console.log(datosRespuesta.estudiante)

                    var db, Perfil, row, crearTablaPerfil, guardarPerfil, consultaPerfil; 

                    Perfil = datosRespuesta.estudiante;

                    db = $cordovaSQLite.openDB({ name: "unicesar.db" });

                    crearTablaPerfil = "CREATE TABLE IF NOT EXISTS Estudiante(Cedula integer primary key, Nombre text,   Apellido text, Rol integer, Facultad text, Programa text, Semestre integer)";

                    guardarPerfil = "INSERT INTO Estudiante(Cedula, Nombre, Apellido, Rol, Facultad, Programa, Semestre)  VALUES(?,?,?,?,?,?,?)";

                    consultaPerfil = "SELECT * FROM Estudiante";

                    $cordovaSQLite.execute(db, crearTablaPerfil);

                    $cordovaSQLite.execute(db, guardarPerfil, [Perfil.CeduEstu, Perfil.NombEstu, Perfil.ApelEstu,    Perfil.RolEstu, Perfil.FacuEstu, Perfil.ProgEstu, Perfil.Semestre]);

                    $cordovaSQLite.execute(db, consultaPerfil).then(function(result){

                        if(result.rows.length > 0) {

                            row = result.rows.item(0);

                            alert("Datos:", row.Cedula +" "+ row.Nombre +" "+ row.Apellido +" "+ row.Rol +" "+ row.Facultad +" "+ row.Programa +" "+ row.Semestre);


                $state.go('Loading');

                $timeout(function() {
                    $state.go(datosRespuesta.estudiante ? 'menuestu' : 'menuprof');
                }, 3000);

         }   

      } else {


            console.log(response.status);
            $scope.respuesta = "Error en la solicitud";
            //$state.go('login');

      };      

    });

};

};`

Export db to sql

This actually works for export db, but i really want to export the db like sql query, you know a way to do that. I try with this plugin https://github.com/dpa99c/cordova-sqlite-porter.

$cordovaFile.copyFile( 'cordova.file.applicationStorageDirectory', 'demo.db', cordova.file.externalDataDirectory, 'newDb.db').then(
   ....
);

Prepared statement failed when swithing from sqlite-storage to sqlite-ext

Greetings,

At first I would like to mention that I am relative new to cordova and the sqlite plugins.

In the documentation sqlite-storage refers to sqlite-ext if you want to use a pre-populated database. But If I adjust my plugin to sqlite-ext the following errors keeps getting up when fetching records:
W/System.err(16153): java.sql.SQLException: prepare statement failed with error: 26
W/System.err(16153): at io.liteglue.SQLiteGlueConnection.prepareStatement(SQLiteGlueConnection.java:45)
W/System.err(16153): at io.sqlc.SQLiteConnectorDatabase.executeSqlStatementNDK(SQLiteConnectorDatabase.java:168)
W/System.err(16153): at io.sqlc.SQLiteConnectorDatabase.executeSqlBatch(SQLiteConnectorDatabase.java:109)
W/System.err(16153): at io.sqlc.SQLitePlugin$DBRunner.run(SQLitePlugin.java:410)
W/System.err(16153): at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1113)
W/System.err(16153): at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:588)
W/System.err(16153): at java.lang.Thread.run(Thread.java:818)

The test project is located at: https://github.com/ruudsilvrants/cordovadbtest.

Besides this error I would like to ask if using a pre-populated and implicit sqlite-ext is a good solution to the following use-case:
The project is about using +- 25.000 records offline (around 10Mb in size) and additionally updating these with information from the webserver.
What is the best solution to save/import these records in the sqlite database?
The idea was to use the pre-populated database and request the webserver for updated/changes and updating the database on the device.This, to avoid retrieving all records at first start-up.

Thanks in advance,
Ruud

Prepopulated database crashes app ('cannot read propery of undefined')

Android: 6.0
Cordova: 6.1.1
Plugin: cordova-sqlite-ext 0.10.0

I have a file called TEST.db located in my www folder. This file contains a handful of entries. My desire is for my app to be able to read these entries and simply output them via console.log. To avoid any confusion: I run the app on my device, and use GapDebug to catch the console.log messages.

It works fine when I create a new database (i.e. without local file and without createFromLocation), but I want to be able to use a prepopulated db file as well (i.e. with local file and with createFromLocation).

On my device the app just crashes and does not respond. GapDebug shows this error:

index.js:43 Uncaught TypeError: Cannot read property 'openDatabase' of undefined

Line 43 refers to: "var db = window.sqlitePlugin.openDatabase"

onDeviceReady: function () {
        var db = window.sqlitePlugin.openDatabase(
            {
                name: 'TEST.db',
                location: 'default',
                createFromLocation: 1
            });
}

possible memory overload?

Hi Chris,
Thanks for the plugin - it definitely helps make things a bit easier. I have searched around internet and it looks like there is no info about memory overload using cordova-sqlite-ext. I've been working on a bible readings app testing mostly with Web SQL (window.openDatabase) in Chrome browser and it works quite well (it's much faster for testing); when I compile it to android it also starts working but suddenly stops after the alert (see below - this is how I tested it). The sqlite database "bible.db" is around 32MB, and there are 3 to 4 sql requests to the database every time the function is called. Like I said it works well in the browser; also, I tested opening small amounts of data and it works most of the time (like only one of the 3 or 4 requests - to get one reading). It also displays everything up to and including "alert("it stops after this");". I will continue to test it out, but any advice would be appreciated - I will also leave an update if I find a solution. I hope there is enough info here - I am new to Cordova though.

`
document.addEventListener("deviceready", onDeviceReady, false);
var db;

function onDeviceReady() {
db = window.sqlitePlugin.openDatabase({name: 'bible.db', location: 'default', createFromLocation: 1});
}



function yayB(day){   //a datepicker calls on yayB() and passes in the day as a date

db.transaction(function (tx) {
    tx.executeSql('select * from Readings where Date ='+"'"+day+"'", [], getReadings, errorCB);

})
}



function errorCB(err) {
alert("Error processing SQL: "+err.code);
}



var q = "'"; //quotes
var bt = " between ";
var equals = "=";
var from = ">=";
var upto = "<=";
var and = " and ";
var or = " or ";
var ch = "Chapter";
var vr = "Verse";
var op = "(";
var cp = ")";
var base = 'select * from Content where Book=';
var reading;
var readingID;





function getReadings(tx, results) {
    var items = results.rows.item(0);
    var columns = {FirstReading : 'First Reading', Psalm : 'Psalm', SecondReading : 'Second Reading', Gospel:'Gospel'};
    var day = items.Day
    var textDay= '<h1 id="day">' + day + '</p> <h2 id="title"></h2><div id="readings"></div>  <h2 id="title"></h2><div id="readings"></div>  <h2 id="title"></h2><div id="readings"></div>  <h2 id="title"></h2><div id="readings"></div>' ;                                 //day title
    document.getElementById("deviceready").innerHTML = textDay;
    for(key in columns){
        if (items[key]){                                                   //readings loop
            reading = items[key];
            readingID = key;
            var readingTitle = columns[key];
            var bookname = reading.match(/(\d )?[A-z]+/)[0];
            var book = getBookNb(bookname);
            var unclean_chapters = reading.match(/\d+:/g);
            var chapters = clean(unclean_chapters);
            var b = reading.split(":");
            var sqlselect = base + book + and;                     //select book
            for(var i=1; i < b.length; i++){                               //chapters loop
                var chapter = chapters[i-1];
                if (i != 1){
                    sqlselect += or;
                }
                sqlselect += op + ch + equals + chapter + and + op;//select chapter
                var sp = b[i].split(",");
                var dd; //double-dash
                for (v in sp){                                     
                    var verse = sp[v].match(/\d+(-\d+)?/)[0];              //verses loop
                    if (v != 0){
                        sqlselect += or;
                    }
                    if (dd === true){
                        dd = false;// unset dd
                        sqlselect += op + vr + upto + verse + cp;     //select verse before double-dash w/pattern (Nb--)
                        continue;
                    }
                    alert("it stops after this");
                    if (sp[v].includes("--")){                     
                        dd = true;// set dd for next verse upto (--verse)
                        sqlselect += op + vr + from + verse + cp;     //select verse after double-dash w/pattern (--Nb)
                        continue;
                        alert("this message is not displayed");
                    }
                     
                    if (sp[v].includes("-")){
                        var vs = verse.split("-");
                        sqlselect += op + vr + bt + vs[0] + and + vs[1] + cp;//select verses between w/pattern (Nb-Nb) 
                        continue;
                    }
                    sqlselect += op + vr + equals + verse + cp;                   //select single verse (Nb,)
                }
                sqlselect += cp + cp;
                
            }
            tx.executeSql(sqlselect, [], queryD, errorCB);     ; // get readings  from database
            document.getElementById("title").innerHTML = readingTitle + " (" + reading + ")";
            document.getElementById("title").id =  readingID;

        }
    }
   
}


 function queryD(tx, results) {
    var text ='<div class="outer">';
    var len = results.rows.length;
    for (var i = 0; i < len; i++) {
    text +=
    '<div class="chunk">'+
    '<div class="foreign">'+
    results.rows.item(i).Original +
    '</div>'+
    '<div class="translation">'+
    results.rows.item(i).Translation +
    '</div>'+
    '<div class="pronunciation">'+
    results.rows.item(i).Pronunciation +
    '</div>'+
    '</div>';
    var book = results.rows.item(i).Book;
    }
    text +="</div>";
       
    if (book<=39){
    document.getElementById("readings").dir = "rtl";
    }
    document.getElementById("readings").innerHTML = text;
    document.getElementById("readings").id = readingID;
}
    

function clean(unclean) { //helper function to clean spaces and colons
    var cleaned = [];
    for (item in unclean){
        cleaned.push(unclean[item].replace(/\s|:/g,""));    
    }
    return cleaned;
}
    
function getBookNb(key){  //helper function to get bookname
    var booknames = {
        'Genesis':1,
        'Exodus':2,
        'Leviticus':3,
        'Numbers':4,
        'Deuteronomy':5,
        'Joshua':6,
        'Judges':7,
        'Ruth':8,
        '1 Samuel':9,
        '2 Samuel':10,
        '1 Kings':11,
        '2 Kings':12,
        '1 Chronicles':13,
        '2 Chronicles':14,
        'Ezra':15,
        'Nehemiah':16,
        'Esther':17,
        'Job':18,
        'Psalms':19,
        'Proverbs':20,
        'Ecclesiastes':21,
        'Sirach':21,
        'Solomon':22,
        'Isaiah':23,
        'Jeremiah':24,
        'Lamentations':25,
        'Ezekiel':26,
        'Daniel':27,
        'Hosea':28,
        'Joel':29,
        'Amos':30,
        'Obadiah':31,
        'Jonah':32,
        'Micah':33,
        'Nahum':34,
        'Habakkuk':35,
        'Zephaniah':36,
        'Haggai':37,
        'Zechariah':38,
        'Malachi':39,
        'Matthew':40,
        'Mark':41,
        'Luke':42,
        'John':43,
        'Acts':44,
        'Romans':45,
        '1 Corinthians':46,
        '2 Corinthians':47,
        'Galatians':48,
        'Ephesians':49,
        'Philippians':50,
        'Colossians':51,
        '1 Thessalonians':52,
        '2 Thessalonians':53,
        '1 Timothy':54,
        '2 Timothy':55,
        'Titus':56,
        'Philemon':57,
        'Hebrews':58,
        'James':59,
        '1 Peter':60,
        '2 Peter':61,
        '1 John':62,
        '2 John':63,
        '3 John':64,
        'Jude':65,
        'Revelation':66,
    };
    
    return booknames[key];
}

`

Proper way of updating pre-populated database

The pre-populated database file is ignored if the database file with the same name already exists in your database file location.

What is the suggested steps of forcing an app to to get the latest version of a pre-populated database (I have both updated existing rows, and added new ones, but the changes are not reflected unless the app is uninstalled first)?

  1. Rename database to a new unique name
  2. Close connection to old database
  3. Delete old database
  4. Open new database

And repeat these steps (for all versions) every time I make changes?

Is there a guide covering this use case somewhere?

When should i call db.close() and openDatabase ?

Is it efficient to call openDatabase and db.close in the onPause and onResume handlers for the application lifecycle? This way i can create a single and global Db instance that i use for all of my transactions.
the other approach would be to create a new Db instance before any transaction and close it in the transaction onSuccess/orError callbacks

which approach is better?

Unable to execute sql query in windows 10 UWP

I'm getting below exception when I tried execute below query from existing database.

"Object doesn't support property or method 'executeSql'"

I used below code for testing.

       var db1 = window.sqlitePlugin.openDatabase({ name: 'mosaic_app', location: 0 });
        db1.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);
        });

What I'm doing wrong?

build on phonegap error on phonegap-version 6.1.0 

Error - Plugin error (you probably need to remove plugin files from your app): Fetching plugin "cordova-sqlite-ext" via npm Installing "cordova-sqlite-ext" at "0.10.0" for android Failed to install 'cordova-sqlite-ext':CordovaError: Uh oh! 
"/tmp/gimlet/23886140/2058005/www_android/project/cordova/plugins/cordova-sqlite-ext/node_modules/cordova-sqlite-ext-deps/libs/sqlite-connector.jar" not found! at copyFile (/tmp/gimlet/23886140/2058005/www_android/project/cordova/lib/pluginHandlers.js:182:36) at copyNewFile (/tmp/gimlet/23886140/2058005/www_android/project/cordova/lib/pluginHandlers.js:214:5) at handlers.source-file.install 
(/tmp/gimlet/23886140/2058005/www_android/project/cordova/lib/pluginHandlers.js:34:13) at Object.ActionStack.process 
(/tmp/gimlet/23886140/2058005/www_android/project/cordova/node_modules/cordova-common/src/ActionStack.js:56:25) at Api.addPlugin (/tmp/gimlet/23886140/2058005/www_android/project/cordova/Api.js:205:20) 
at handleInstall (/home/ec2-user/.npm/lib/node_modules/pgb-plugman/node_modules/pgb-cordova-lib/src/plugman/install.js:602:6) at /home/ec2-user/.npm/lib/node_modules/pgb-plugman/node_modules/pgb-cordova-lib/src/plugman/install.js:391:24 at _fulfilled (/home/ec2-user/.npm/lib/node_modules/pgb-plugman/node_modules/q/q.js:787:54) at self.promiseDispatch.done (/home/ec2-user/.npm/lib/node_modules/pgb-plugman/node_modules/q/q.js:816:30) at Promise.promise.promiseDispatch (/home/ec2-user/.npm/lib/node_modules/pgb-plugman/node_modules/q/q.js:749:13) Uh oh! 
"/tmp/gimlet/23886140/2058005/www_android/project/cordova/plugins/cordova-sqlite-ext/node_modules/cordova-sqlite-ext-deps/libs/sqlite-connector.jar" not found! - You can fix this here

This is the bug report:

The most likely cause for this error is error is that you have included plugin javascript files in your app package, such as barcodescanner.js, GAPlugin.js, cdv-plugin-fb-connect.js, or any other plugin files such as the childbrowser assets directory.

Previously we used pluginstall to install plugins, which would simply overwrite files in your app. However we recently migrated to plugman, which will not overwrite these files and instead fails.

How to debug / view database

Can not view the SQL database without root access to the data/data folder. How would it be possible to view the sql file generated by this plugin and the data stored inside?

Work on android not on ios

I use this plugin to build android and ios app. i used angularjs and cordova. The android app work perfect but the ios not work at the pages which must select from sqlite. My code is :

 var statement = "";
    db.transaction(function (tx) {
    statement = "select * from pictures where objectid='"+$scope.Axiotheata.OBJECTID+"'";
    tx.executeSql(statement, [], function (tx, res) {

        for(var i=0;i<res.rows.length;i++){

            $scope.AxiotheataImagesArray[i]=res.rows.item(i);
            $scope.$apply();
        }
    }, function (e) {
        alert("Something went wrong");

    });

}, function (e) {
    alert('transaction error: ' + e.message);
  });

It is my first time that use this plugin and make app. Is there any solution about this? Thanks in advance.

Is this version included in PouchDB?

The README says that it is, but in the PouchDB project, I only find references to the standard Cordova-sqlite-storage.

For example, in run-cordova.sh.

Ultimately, my goal is to use a pre-populated database with PouchDB in Cordova.

INSERT BLOB data from Base64

This version already has the BASE64 function which can be used to SELECT BLOB data in Base64 format. This works well with the internal JSON interface as well as some important JavaScript libraries.

It would also be nice to be able to INSERT BLOB data from a Base64 value. This would involve adding another user defined function such as FROMBASE64 or BLOB_FROM_BASE64 which would basically decode a Base64 value.

Just like the BASE64 function uses a modified version of cencode.c from http://libb64.sourceforge.net/ (see https://github.com/brodybits/sqlite3-base64) the new FROMBASE64 function would probably use a possibly modified version of cdecode.c from http://libb64.sourceforge.net/.

new transaction is waiting for open operation

Hello @brodybits ,

Hope you are doing well.

I have integrated this plugin in my ionic application it works like charm.

But suddenly i am getting this console log
"new transaction is waiting for open operation"

image

here is my code

 if (window.sqlitePlugin !== undefined) {
        db = window.sqlitePlugin.openDatabase({ name: "Jewellary.db", location: 2, createFromLocation: 1 ,androidDatabaseImplementation: 2});

}

Here db is variable which will be use as for firing queries in application
and following is my code to fire queries

 var user_Query = "SELECT * FROM setting WHERE id = 1 AND is_valid = 1";
        $cordovaSQLite.execute(db, query, []).then(function (res) {
          console.log("success" );
          if (res.rows.length > 0) {
            is_valid = true;
          } else {
            is_valid = false;
          }
        })

Pre populated databases do not get copied on Windows universal

Please note that this issue is only related to windows universal platform

The pre populated database is in www directory and the following tests were done on Windows 10 emulator through Visual Studio 2015

  1. To start with the plugin docs states that the pre populated db can be initialized as below.
    var db = window.sqlitePlugin.openDatabase({name: "my.db", createFromLocation: 1});
    But this gives the following error

    Error: Database location or iosDatabaseLocation value is now mandatory in openDatabase call

  2. If I open the db as window.sqlitePlugin.openDatabase({name: 'mydb.db',location: 0} it will output the following on the console.

    OPEN database: mydb.db
    open db name: mydb.db at full path: C:\Data\Users\DefApps\AppData\Local\Packages\com.packagename.etc_XXXXXX\LocalState\mydb.db

  3. When I perform a select query on the database it gives

    sql exception error: Error preparing an SQLite statement

I have tried executeSql as well as running executeSql inside a transaction but experienced the same result.

4.But when I run a create table query, instead of the select query, it works fine. So after running few queries such as "pragma page_count" it is clear that the pre populated database was not copied/created on the device. Instead it has created an empty database in the above path. I have also tried opening database with different locations, on different emulators, also by deleting the app but nothing worked.

5.The size of the database is about 10mb. Is there a limitation to the database size on Windows? I haven't tested this plugin with a small sized database but this works well on both Android and iOS with the same database. (actually I have used the basic version of this plugin litehelpers/Cordova-sqlite-storage for android and ios)

Please advise if anyone is aware of this issue and can be fixed through my code/plugin or if its a limitation on Windows platform.

Thanks

Pre-populated Databases Question

This is just super awesome! Okay just one VERY IMPORTANT question:

Prior to now, to use pre-populated dbs, we had to use cordova-plugin-dbcopy together with the Cordova-sqlite-storage
(core), THE VERY IMPORTANT question is: does it mean with cordova-sqlite-ext, I can just place prepopulated.db in www, plug my Android device, run ionic run android, unplug it and continue testing away?

(BTW I saw the https://github.com/jdnichollsc/Ionic-Starter-Template, it is nice but a little not-like-default-ionic. Also, that starter assumes that only one db is to be used in the project, and that db is known at design time. In reality, some apps (like a book apps) require that additional dbs be downloaded after the app is installed. Plus, we are months into our development so no option for starter templates.)

UPDATE I guess I am wrong in saying I used two databases with Ionic. Actually I merely substituted one for another and it worked for whatever reason. Now I try to substitute it back and the first one is the one still loading, even though I have changed it! Weird!

No such table (Ionic 2 framework)

This is my code.

this.database = new SQLite();  
this.database.openDatabase({name: "database.sqlite", location: "default", createFromLocation: 1})

If I change the name of the database the console says the database is opened even though it doesn't exist.

Device stop working after query

I am having an issue, I am using ioinic2 (witu SqlStorage) and I am having an issue selecting a row using a couple of JOINS, the query is not big, also I was having an issue selecting 200 records from a single table.

The application just quit and exit.

Error reading Blobs Android

Hi @everyone

I am writing a app and have a error when I need to read data from a table with a blob field. This app is used for maps with GeoPackage. The following code is how I am using the plugin:

_db = window.sqlitePlugin.openDatabase({ name: _name, location: 'default', androidDatabaseImplementation: 2, createFromLocation: 1 });
var query='SELECT tile_data FROM tiles ';

The app broken

Thanks for your help

Pre-populated database samples & links

There is already an Ionic starter template with pre-populated database support but I think a simpler sample could help some users. Ideally with and without Ionic.

An 2014 article by Raboy still seems to be relevant though it could use some very minor updates. I think it should go back in README.md. It has apparently moved to: https://www.thepolyglotdeveloper.com/2014/11/use-sqlite-instead-local-storage-ionic-framework

I wonder if there are some more recent tutorials and other articles?

Can't work with BLOB

Hello everyone

I watched that this plugin has one limitation with the blob field. I want to know what I can do to work with this type field. I am working with a Android. Thanks

Problem "SELECT" new tables in db

i got this error:
sql exception error: Error preparing an SQLite statement.
After 1 week working on the project i've just added a new table in the db.

The old table using a simple select like thisworks perfectly:

db.transaction(function(transaction)
{
transaction.executeSql('SELECT * FROM GB00_LETTURISTI;', [],
function(transaction, result) {
if (result != null && result.rows != null)
{
for (var i = 0; i < result.rows.length; i++)
{
var row = result.rows.item(i);
console.log(row.GB00_COD_LETTURISTA);

      $('#sel1').append('<option> ' + row.GB00_COD_LETTURISTA + ' </option>');
    }

  }
 },errorHandler);

},errorHandler,nullHandler);

but using a simple select on the new table named GB02_ANAG_CONDOMINI using this code:

db.transaction(function (transaction) {
transaction.executeSql('SELECT * FROM GB02_ANAG_CONDOMINI;', [],
function (transaction, result) {
if (result != null && result.rows != null) {
for (var i = 0; i < result.rows.length; i++) {
var row = result.rows.item(i);

                  console.log(row.GB02_ID_CONDOMINIO);

              }

          }
      }, errorHandler);
}, errorHandler, nullHandler);

gives me this error:
DB opened: RiescoDB.db
sql exception error: Error preparing an SQLite statement.
Error: Error preparing an SQLite statement. code: -1

i use a pre populated db located in the "www" path. connecting it with this code:
db = window.sqlitePlugin.openDatabase({ name: "RiescoDB.db", location: 'default', createFromLocation: 1 });

i'm developing with vs2015 for a windows cordova based project in javascript

Regarding sqlite-ext build ios

I am still a noob in developing mobile app, and thanks to brodybits for helping me with the database plugins.

Just want to make sure if anyone has problems with building ios command via cordova build ios and always facing error with code 65. The way i fix this is to remove the cordova-sqlite-ext plugin then add it again. Dont remove the platform with rm -rf or cordova remove platform command, just re-install this plugin then the trouble will go away.

Good luck to us all.. brodybits 👍 thanks dude

iOS issue with prepopulated DB

Hi,
we've made an Ionic/Cordova project where a lot of html files need to be displayed and their contents need to be searchable.
So we populated a sqlite database containing only the fts4 tables filled with all innerTexts of the html contents.
It works pretty nice on Android tablets, but the same app gives errors on iOS.

First, window.sqlitePlugin.openDatabase({name: "ld_fts.db", location: 2, fromLocation: 1}) doesn't copy the db - and, yes, it's been called on deviceready. I used the recommended alternative cordova-plugin-dbcopy and this works for us. So this is not an issue.

Second, if the search seems to get a lot of results an error is printed to an attached Safari console and states 'SyntaxError: Unexpected EOF', neither the error nor the success callback of db.executeSql is called from the plugin. (e.g. search for thc works fine, search for diagnose fails).

The db is 30MiB in size. I have got a sample project at hand, which I can send, if needed.

Pre-populated sqlite db on android developer app

Greetings Chris..
I needed to open a pre-populated sqlite db in android I added your cordova-sqlite-ext and it worked fine when I compiled it for android. I added it to the "Andoid Developer App" but it will not open the existing db in the www folder using
var db = window.sqlitePlugin.openDatabase({name: "my.db", createFromLocation: 1});
It assumes it's not there and creates a new one in the databases folder of the Andoid Developer App. Do have an suggestions.
Thank you in advance for your time..
Cheers..
Groetjes... (my wife is from Eindhoven)..

Unable to begin transaction: cannot start a transaction within a transaction.

I am using the cordova-sqlite-ext plugin for a mobile app I am developing (iOS and Android). I am running in to a problem where I get this ERROR:

Unable to begin transaction: cannot start a transaction within a transaction.

It's really a bummer. 😞
lol
So i've tried a number of things - and have found lots of doc'n in the readme. Some things I tried:

  1. Closing the dbase (see Readme > "Close a database object"). For some reason the dbase did not re-open when I switch to the page where the test button is.
  2. Used a callback to make sure the transaction completed. I had an alert pop up to verify transaction was complete. However, I still got the above error.

So it's still not working. It seems my UPDATE transaction is not committed. Sometimes it works upon first start up of the app, but then it won't commit when I go and try to repeat the update with a new value. That's when I get the above error.

I think it might be because I have kicked off two functions which run at the same time but in different directions.

User clicks a link on page 1. This kicks off two functions at the same time:
Function 1 Does an UPDATE query adding to a record in the dbase. This is a transaction.executeSql inside a db.transaction.
Function 2 Opens a new page and will try to populate a listview with a ...
transaction.executeSql SELECT query.
This is also a transaction.executeSql inside a db.transaction.

It's strange cuz neither the built-in error nor success message shows. I only see page 2 open - showing only the header. For some reason the listview has failed to open. I have other error handlers which also fail to fire.

Then I go to a test page and click a button to verify the changed record in the database. Sometimes the record is updated, sometimes I get the above error msg. If i click OK, then click the same button again, this time it shows the record - and it will not be updated.

I am wondering if Function 2 crashes for some reason and this stops Function 1 from completing?

Is this a common problem?

Visual Studio 2015 and apache cordova project

------ Build started: Project: Magic, Configuration: Debug Windows-x86 ------
Your environment has been set up for using Node.js 0.12.2 (ia32) and npm.
------ Ensuring correct global installation of package from source package directory: C:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\IDE\Extensions\ApacheCordovaTools\packages\vs-tac
------ Name from source package.json: vs-tac
------ Version from source package.json: 1.0.37
------ Package already installed globally at correct version.
------ Cordova tools 6.0.0 already installed.
------ Build Settings:
------ Build Settings:
------ platformConfigurationBldDir: C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\bld\Windows-x86\Debug
------ platformConfigurationBinDir: C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\bin\Windows-x86\Debug
------ buildCommand: build
------ platform: Windows-x86
------ cordovaPlatform: windows
------ configuration: Debug
------ cordovaConfiguration: Debug
------ projectName: Magic
------ projectSourceDir: C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic
------ npmInstallDir: C:\Users\mgome\AppData\Roaming\npm
------ buildTarget: LocalMachine
------ language: en-US
------ Platform windows already exists
------ Copying native files from C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\native\windows to platforms\windows
------ Copied C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\native\windows\CordovaApp.pfx to platforms\windows\CordovaApp.pfx
------ Done copying native files to platforms\windows
------ Updating plugins
------ Currently installed plugins: [email protected],[email protected],[email protected],[email protected],[email protected],[email protected]
------ Currently installed dependent plugins:
------ Currently configured plugins:
------ Preparing platform: windows
Executing "before_prepare" hook for all plugins.
Executing "before_build" hook for all plugins.
Searching PlatformJson files for differences between project vs. platform installed plugins
No differences found between project and windows platform. Continuing...
Generating config.xml from defaults for platform "windows"
Found "merges" for windows platform. Copying over existing "www" files.
Copying image from C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\icons\windows\Square150x150Logo.scale-100.png to C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\platforms\windows\images\Square150x150Logo.scale-100.png
Copying image from C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\icons\windows\Square150x150Logo.scale-240.png to C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\platforms\windows\images\Square150x150Logo.scale-240.png
Copying image from C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\icons\windows\Square30x30Logo.scale-100.png to C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\platforms\windows\images\Square30x30Logo.scale-100.png
Copying image from C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\icons\windows\Square310x310Logo.scale-100.png to C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\platforms\windows\images\Square310x310Logo.scale-100.png
Copying image from C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\icons\windows\Square44x44Logo.scale-100.png to C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\platforms\windows\images\Square44x44Logo.scale-100.png
Copying image from C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\icons\windows\Square44x44Logo.scale-240.png to C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\platforms\windows\images\Square44x44Logo.scale-240.png
Copying image from C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\icons\windows\Square70x70Logo.scale-100.png to C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\platforms\windows\images\Square70x70Logo.scale-100.png
Copying image from C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\icons\windows\Square71x71Logo.scale-100.png to C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\platforms\windows\images\Square71x71Logo.scale-100.png
Copying image from C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\icons\windows\Square71x71Logo.scale-240.png to C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\platforms\windows\images\Square71x71Logo.scale-240.png
Copying image from C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\icons\windows\StoreLogo.scale-100.png to C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\platforms\windows\images\StoreLogo.scale-100.png
Copying image from C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\icons\windows\StoreLogo.scale-240.png to C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\platforms\windows\images\StoreLogo.scale-240.png
Copying image from C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\icons\windows\Wide310x150Logo.scale-100.png to C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\platforms\windows\images\Wide310x150Logo.scale-100.png
Copying image from C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\icons\windows\Wide310x150Logo.scale-240.png to C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\platforms\windows\images\Wide310x150Logo.scale-240.png
Copying image from C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\screens\windows\SplashScreen.scale-100.png to C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\platforms\windows\images\SplashScreen.scale-100.png
Copying image from C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\screens\windows\SplashScreen.scale-240.png to C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\platforms\windows\images\SplashScreenPhone.scale-240.png
Copying image from C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\res\screens\windows\SplashScreenPhone.scale-240.png to C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\platforms\windows\images\SplashScreenPhone.scale-240.png
Updated project successfully
Executing "pre_package" hook for all plugins.
Executing "after_prepare" hook for all plugins.
------ Copied C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\bin\Windows-x86\Debug\Microsoft.AppxPackage.Metadata.Overrides.props to platforms\windows\Microsoft.AppxPackage.Metadata.Overrides.props
------ Building platform: windows
Debug
------ Build configuration options: --debug
Executing "before_compile" hook for all plugins.
Reading build config file: C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\build.json
Searching for available MSBuild versions...
Found MSBuild v4.0 at C:\Windows\Microsoft.NET\Framework\v4.0.30319
Found MSBuild v12.0 at C:\Program Files (x86)\MSBuild\12.0\bin
Found MSBuild v14.0 at C:\Program Files (x86)\MSBuild\14.0\bin
Building project: C:\Users\mgome\documents\visual studio 2015\Projects\Magic\Magic\platforms\windows\CordovaApp.Windows10.jsproj
Configuration : debug
Platform : x86
Constants.cpp
c:\users\mgome\documents\visual studio 2015\projects\magic\magic\plugins\cordova-sqlite-ext\src\windows\sqlite3-win-rt\sqlite3\constants.cpp(1): warning C4627: '#include "Constants.h"': skipped when looking for precompiled header use [C:\Users\mgome\Documents\Visual Studio 2015\Projects\Magic\Magic\plugins\cordova-sqlite-ext\src\windows\SQLite3-Win-RT\SQLite3\SQLite3.UWP\SQLite3.UWP.vcxproj]
c:\users\mgome\documents\visual studio 2015\projects\magic\magic\plugins\cordova-sqlite-ext\src\windows\sqlite3-win-rt\sqlite3\constants.cpp(1): note: Add directive to 'pch.h' or rebuild precompiled header
c:\users\mgome\documents\visual studio 2015\projects\magic\magic\plugins\cordova-sqlite-ext\src\windows\sqlite3-win-rt\sqlite3\constants.cpp(2): fatal error C1010: unexpected end of file while looking for precompiled header. Did you forget to add '#include "pch.h"' to your source? [C:\Users\mgome\Documents\Visual Studio 2015\Projects\Magic\Magic\plugins\cordova-sqlite-ext\src\windows\SQLite3-Win-RT\SQLite3\SQLite3.UWP\SQLite3.UWP.vcxproj]
Database.cpp
c:\users\mgome\documents\visual studio 2015\projects\magic\magic\plugins\cordova-sqlite-ext\src\windows\sqlite3-win-rt\sqlite3\database.cpp(1): warning C4627: '#include "Winerror.h"': skipped when looking for precompiled header use [C:\Users\mgome\Documents\Visual Studio 2015\Projects\Magic\Magic\plugins\cordova-sqlite-ext\src\windows\SQLite3-Win-RT\SQLite3\SQLite3.UWP\SQLite3.UWP.vcxproj]
c:\users\mgome\documents\visual studio 2015\projects\magic\magic\plugins\cordova-sqlite-ext\src\windows\sqlite3-win-rt\sqlite3\database.cpp(1): note: Add directive to 'pch.h' or rebuild precompiled header
c:\users\mgome\documents\visual studio 2015\projects\magic\magic\plugins\cordova-sqlite-ext\src\windows\sqlite3-win-rt\sqlite3\database.cpp(3): warning C4627: '#include "Database.h"': skipped when looking for precompiled header use [C:\Users\mgome\Documents\Visual Studio 2015\Projects\Magic\Magic\plugins\cordova-sqlite-ext\src\windows\SQLite3-Win-RT\SQLite3\SQLite3.UWP\SQLite3.UWP.vcxproj]
c:\users\mgome\documents\visual studio 2015\projects\magic\magic\plugins\cordova-sqlite-ext\src\windows\sqlite3-win-rt\sqlite3\database.cpp(3): note: Add directive to 'pch.h' or rebuild precompiled header
c:\users\mgome\documents\visual studio 2015\projects\magic\magic\plugins\cordova-sqlite-ext\src\windows\sqlite3-win-rt\sqlite3\database.cpp(4): warning C4627: '#include "Statement.h"': skipped when looking for precompiled header use [C:\Users\mgome\Documents\Visual Studio 2015\Projects\Magic\Magic\plugins\cordova-sqlite-ext\src\windows\SQLite3-Win-RT\SQLite3\SQLite3.UWP\SQLite3.UWP.vcxproj]
c:\users\mgome\documents\visual studio 2015\projects\magic\magic\plugins\cordova-sqlite-ext\src\windows\sqlite3-win-rt\sqlite3\database.cpp(4): note: Add directive to 'pch.h' or rebuild precompiled header
c:\users\mgome\documents\visual studio 2015\projects\magic\magic\plugins\cordova-sqlite-ext\src\windows\sqlite3-win-rt\sqlite3\database.cpp(56): fatal error C1010: unexpected end of file while looking for precompiled header. Did you forget to add '#include "pch.h"' to your source? [C:\Users\mgome\Documents\Visual Studio 2015\Projects\Magic\Magic\plugins\cordova-sqlite-ext\src\windows\SQLite3-Win-RT\SQLite3\SQLite3.UWP\SQLite3.UWP.vcxproj]
Statement.cpp
c:\users\mgome\documents\visual studio 2015\projects\magic\magic\plugins\cordova-sqlite-ext\src\windows\sqlite3-win-rt\sqlite3\statement.cpp(1): warning C4627: '#include "Winerror.h"': skipped when looking for precompiled header use [C:\Users\mgome\Documents\Visual Studio 2015\Projects\Magic\Magic\plugins\cordova-sqlite-ext\src\windows\SQLite3-Win-RT\SQLite3\SQLite3.UWP\SQLite3.UWP.vcxproj]
c:\users\mgome\documents\visual studio 2015\projects\magic\magic\plugins\cordova-sqlite-ext\src\windows\sqlite3-win-rt\sqlite3\statement.cpp(1): note: Add directive to 'pch.h' or rebuild precompiled header
c:\users\mgome\documents\visual studio 2015\projects\magic\magic\plugins\cordova-sqlite-ext\src\windows\sqlite3-win-rt\sqlite3\statement.cpp(3): warning C4627: '#include "Statement.h"': skipped when looking for precompiled header use [C:\Users\mgome\Documents\Visual Studio 2015\Projects\Magic\Magic\plugins\cordova-sqlite-ext\src\windows\SQLite3-Win-RT\SQLite3\SQLite3.UWP\SQLite3.UWP.vcxproj]
c:\users\mgome\documents\visual studio 2015\projects\magic\magic\plugins\cordova-sqlite-ext\src\windows\sqlite3-win-rt\sqlite3\statement.cpp(3): note: Add directive to 'pch.h' or rebuild precompiled header
c:\users\mgome\documents\visual studio 2015\projects\magic\magic\plugins\cordova-sqlite-ext\src\windows\sqlite3-win-rt\sqlite3\statement.cpp(4): warning C4627: '#include "Database.h"': skipped when looking for precompiled header use [C:\Users\mgome\Documents\Visual Studio 2015\Projects\Magic\Magic\plugins\cordova-sqlite-ext\src\windows\SQLite3-Win-RT\SQLite3\SQLite3.UWP\SQLite3.UWP.vcxproj]
c:\users\mgome\documents\visual studio 2015\projects\magic\magic\plugins\cordova-sqlite-ext\src\windows\sqlite3-win-rt\sqlite3\statement.cpp(4): note: Add directive to 'pch.h' or rebuild precompiled header
c:\users\mgome\documents\visual studio 2015\projects\magic\magic\plugins\cordova-sqlite-ext\src\windows\sqlite3-win-rt\sqlite3\statement.cpp(91): fatal error C1010: unexpected end of file while looking for precompiled header. Did you forget to add '#include "pch.h"' to your source? [C:\Users\mgome\Documents\Visual Studio 2015\Projects\Magic\Magic\plugins\cordova-sqlite-ext\src\windows\SQLite3-Win-RT\SQLite3\SQLite3.UWP\SQLite3.UWP.vcxproj]
Generating Code...
ERROR building one of the platforms : error C: \Program Files (x86)\MSBuild\14.0\bin\msbuild.exe: Command failed with exit code 1
You may not have the required environment or OS to build this project
MSBUILD : cordova-build error : Error: C:\Program Files (x86)\MSBuild\14.0\bin\msbuild.exe: Command failed with exit code 1
MDAVSCLI : error C: \Program Files (x86)\MSBuild\14.0\bin\msbuild.exe: Command failed with exit code 1
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========
========== Deploy: 0 succeeded, 0 failed, 0 skipped ==========

windows VS project corrupt

I'm having trouble to use the plugin for platform windows with visual studio 2015.

The VS workspace file cordova-sqlite-ext/src/windows/SQLite3-Win-RT/SQLite3/SQLite3.sln targets 3 subprojects:

Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SQLite3.Shared", "SQLite3\SQLite3.Shared\SQLite3.Shared.vcxitems", "{DB84AE51-4B93-44F5-BE22-1EAE1833ECEC}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SQLite3.Windows", "SQLite3\SQLite3.Windows\SQLite3.Windows.vcxproj", "{D1848FEE-6A8E-4EF1-8BFB-8652E5A9CD4A}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SQLite3.WindowsPhone", "SQLite3\SQLite3.WindowsPhone\SQLite3.WindowsPhone.vcxproj", "{6435C2E4-4FD2-405A-9EE2-5312AE852782}"
EndProject

BUT there are only 2 folders for Windows and WindowsPhone. The shared file is in same directory and not in subfolder SQLite3.Shared. Additionally to that, the workspace file is already in folder SQLite3, so the first part of the path "SQLite3" should not be there.

Am I right or what am I doing wrong?

(If you are changing the reference, then pay attention to the subprojects Windows and WindowsPhone. They are referencing the shared file too)

After I changed the references, the plugin starts building but fails some steps later anyways.
fatal error C1083: File (Include) could not be opened: "vccorlib.h"
I started copying about 30-40 files from Windows Kit and Visual Studio / libs folder to the plugin workspace folder to solve one error after another. Am I missing some SDKs, Windows Kits, library configurations, ...?!

Running on windows 10, cannot open database

When running on local machine / emulator works perfectly. Remotely debugging or installing appx package on tablet is throwing cannot open database error.

Looks like a permission error somewhere ?

Get this using a newly created project and adding only sqlite-ext plugin through cordova cli.

Read only in www folder

I have a prepopulated db of several hundreds of mb, and upon startup, the app size is doubled because de createfromlocation function copies the database instead of moving it. Can an option be added to move instead of copy or can you open a read only db in www?

Unclear build process

Previously I have been using cordova-sqlite-storage without any issue but I now need to provide support to Windows 10 phones.
I have removed sqlite-storage and added sqlite-ext but when i run ionic build windows i get:

error APPX0505: The processor architecture of your project 'neutral' doesn't match the processor architecture 'x86' of the referenced project 'SQLite3.UWP'. Change the targeted processor architectures to align between your project and its references.

I then tried ionic build windows --arch=arm and although that seemed to build a the VS solution, i could not deploy the app to the device as VS was giving me this error:

Error MSB3030 Could not copy the file "D:\Development\myproject\platforms\windows\Debug\SQLite3.UWP\SQLite3.winmd" because it was not found

I dont recall having any of these issues with the sqlite-storage plugin and there is very little documentation about specific build steps for sqlite-ext.

Is there a particular build process I should be following to use this plugin?

Crashed: com.apple.root.default-qos

Crashed: com.apple.root.default-qos
EXC_BAD_ACCESS KERN_INVALID_ADDRESS 0x1000000000000000
libobjc.A.dylib : objc_msgSend + 8
CoreFoundation : -[__NSDictionaryM setObject:forKey:] + 360
MyApp : SQLitePlugin.m line 190
-[SQLitePlugin openNow:]
libdispatch.dylib : _dispatch_call_block_and_release + 24
libdispatch.dylib : _dispatch_client_callout + 16
libdispatch.dylib : _dispatch_root_queue_drain + 2140
libdispatch.dylib : _dispatch_worker_thread3 + 112
libsystem_pthread.dylib _p: thread_wqthread + 1092
libsystem_pthread.dylib : start_wqthread + 4

Attached the full crash report
cec_issue_11_crash_da6a350a695146048d8693019d3f9ec6.txt

Using pre-populated DB

Hi,
I want to write an application with a pre- populated db. There for I used the cordova-sqlite-ext

There for I tried the quickstart guid and it went well. If I create a db on start up it went well, too.
But If I try to use my db in the www directory, I get an error evry time I tries to insert code in an existing table.

`var db = window.sqlitePlugin.openDatabase({ name: "Orders.db", location: 1, createFromLocation: 1 });

    db.transaction(function (tx) {
        tx.executeSql('DROP TABLE IF EXISTS tb_auftrag');
        tx.executeSql('CREATE TABLE IF NOT EXISTS tb_auftrag (auftragid integer primary key, kdnr integer)');


        tx.executeSql("INSERT INTO tb_auftrag (auftragid, kdnr) VALUES (?,?)", [12356, 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 auftragid, kdnr from tb_auftrag;", [], function (tx, res) {
                    console.log("res.rows.length: " + res.rows.length );
                    for (i = 0; i <= res.rows.length;i++){
                    console.log("res.rows.item("+i+").auftragid: " + res.rows.item(i).auftragid);
                    console.log("res.rows.item("+i+").kdnr: " + res.rows.item(i).kdnr);
                        }
                },
                function (e) { console.log("Select Error:" + e.message) });

            });

        }, function (e) {
            console.log("ERROR: " + e.message);
        });

    });`

This code works well.

If I set the DROP and CREATE statements to comment I can use the database created once and manipulate and read the data.

But the select ignores all inputs created with SQLiteBrowser in the prepopulated DB and also if I browse the db in www folder I only get the inputs I created with the SQLiteBrowser.

I tried the cordova-plugin-dbcopy to set the db in to the correct directory and I get the responses the db still exists.

If I set this code in front of the code above

var dbname = "Orders.db"; var location = 0; var success = function (e) { console.log("success copy: " + e.message); } var error = function (e) { console.log("error copy: " + e.message); } window.plugins.sqlDB.remove(dbname, location, success, error); window.plugins.sqlDB.copy(dbname, location, success, error);

I get an error on using INSERT and SELECT when not using DROP and or CREATE table.

I hope someone has a soloution for my issue.

Thank you for your respond.

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.