cordova-sqlite-evmax-build-free 0.0.6 → 0.0.7

package/CHANGES.md

@@ -1,5 +1,11 @@
 # Changes
 
+# cordova-sqlite-evmax-build-free 0.0.7
+
+## cordova-sqlite-evmax-common-free 0.0.5-dev
+
+- use android-sqlite-evmax-ndk-driver-free with workaround for slash characters with Capacitor (with SQLite 3.40.0)
+
 # cordova-sqlite-evmax-build-free 0.0.6
 
 - remove useless Windows project references

package/README.md

@@ -52,7 +52,7 @@ under consideration:
 
 ## About this plugin version
 
-Super-premium enterprise version with additional performance and stability improvements for Android, iOS, and macOS, including workarounds for super-large INSERT transactions and SELECT results on Android - with limited extra features (missing pre-populated database support), using the `before_plugin_install` hook to fetch the sqlite3 component dependencies from `cordova-sqlite-evplus-ext-free-dependencies` on GitHub.
+Super-premium enterprise version with additional performance and stability improvements for Android, iOS, and macOS, including workarounds for super-large INSERT transactions and SELECT results on Android - with limited extra features (missing pre-populated database support), using the `before_plugin_install` hook to fetch the sqlite3 component dependencies from <https://github.com/brodybits/cordova-sqlite-evmax-free-dependencies-dev>.
 
 <!-- FUTURE TBD critical bug notices for this plugin version -->
 
@@ -62,7 +62,7 @@ Super-premium enterprise version with additional performance and stability impro
 
 ### Multiple SQLite problem on Android
 
-__This plugin uses non-standard [`storesafe/android-sqlite-evplus-ndk-driver-free`](https://github.com/storesafe/android-sqlite-evplus-ndk-driver-free) sqlite database access implementation on Android. In case an application access the SAME database file using multiple plugins there is a risk of data corruption ref: [`storesafe/cordova-sqlite-storage#626`](https://github.com/storesafe/cordova-sqlite-storage/issues/626) as described in <http://ericsink.com/entries/multiple_sqlite_problem.html> and <https://www.sqlite.org/howtocorrupt.html>.__
+__This plugin uses non-standard [`android-sqlite-evmax-ndk-driver-free`](https://github.com/brodybits/android-sqlite-evmax-ndk-driver-free) sqlite database access implementation on Android. In case an application access the SAME database file using multiple plugins there is a risk of data corruption ref: [`storesafe/cordova-sqlite-storage#626`](https://github.com/storesafe/cordova-sqlite-storage/issues/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](#android-database-provider) section below:
 
@@ -201,7 +201,7 @@ See the [Sample section](#sample) for a sample with a more detailed explanation
 - This plugin version includes the following extra (non-standard) features:
   - BASE64 and BLOBFROMBASE64 integrated from [brodybits / sqlite3-base64](https://github.com/brodybits/sqlite3-base64), using [brodybits / libb64-core](https://github.com/brodybits/libb64-core) (based on <http://libb64.sourceforge.net/> by Chris Venter, public domain)
   - REGEXP for Android (default Android-sqlite-connector database implementation), iOS, and macOS using [brodybits / sqlite3-regexp-cached](https://github.com/brodybits/sqlite3-regexp-cached) (based on <http://git.altlinux.org/people/at/packages/?p=sqlite3-pcre.git> by Alexey Tourbin, public domain)
-- SQLite __(`3.38.5` for Android, `3.40.0` for other platforms)__ included when building (all platforms), with the following compile-time definitions:
+- SQLite __`3.40.0`__ 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](https://github.com/xpbrew/cordova-sqlite-storage/issues/736)
   - `SQLITE_LOCKING_STYLE=1` on iOS/macOS ONLY
@@ -229,9 +229,9 @@ See the [Sample section](#sample) for a sample with a more detailed explanation
   - <https://www.sqlite.org/releaselog/3_26_0.html>
 - The iOS database location is now mandatory, as documented below.
 - This version branch supports the use of two (2) possible Android sqlite database implementations:
-  - default: high-performance, lightweight [`android-sqlite-evplus-ndk-driver-free`](https://github.com/storesafe/android-sqlite-evplus-ndk-driver-free) NDK library (C-language implementation)
+  - default: high-performance, lightweight [`android-sqlite-evmax-ndk-driver-free`](https://github.com/brodybits/android-sqlite-evmax-ndk-driver-free) NDK library (C-language implementation)
   - optional: Android system database implementation, using the `androidDatabaseProvider: 'system'` setting in `sqlitePlugin.openDatabase()` call as described in the [Android database provider](#android-database-provider) section below.
-- The following feature is available in [brodybits/cordova-sqlite-ext](https://github.com/brodybits/cordova-sqlite-ext) (with permissive license terms, missing performance and stability enhancements from [`android-sqlite-evplus-ndk-driver-free`](https://github.com/storesafe/android-sqlite-evplus-ndk-driver-free)), MISSING in this plugin version:
+- The following feature is available in [brodybits/cordova-sqlite-ext](https://github.com/brodybits/cordova-sqlite-ext) (with permissive license terms, missing performance and stability enhancements from [`android-sqlite-evmax-ndk-driver-free`](https://github.com/brodybits/android-sqlite-evmax-ndk-driver-free)), MISSING in this plugin version:
   - Pre-populated database (Android/iOS/macOS/Windows)
 - Windows platform version using a customized version of the performant [doo / SQLite3-WinRT](https://github.com/doo/SQLite3-WinRT) C++ component based on the [brodybits/SQLite3-WinRT sync-api-fix branch](https://github.com/brodybits/SQLite3-WinRT/tree/sync-api-fix), 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](https://github.com/xpbrew/cordova-sqlite-storage/issues/580). Visual Studio 2015 is now supported by [`brodybits/cordova-sqlite-legacy`](https://github.com/brodybits/cordova-sqlite-legacy) (permissive license terms, no performance enhancements for Android) and [`brodybits/cordova-sqlite-evcore-legacy-ext-common-free`](https://github.com/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.)
@@ -261,7 +261,7 @@ See the [Sample section](#sample) for a sample with a more detailed explanation
 
 ## Announcements
 
-- This plugin version includes a super-premium workaround to support super-large INSERT transactions on Android. It also includes premium improvements to the internal JSON interface between Javascript and native parts on Android, iOS, and macOS which improves the performance and resolves memory issues in case of some very large SQL batches and large SELECT results, with help from [`android-sqlite-evplus-ext-native-driver-free`](https://github.com/storesafe/android-sqlite-evplus-ext-native-driver-free) on Android.
+- This plugin version includes super-premium workarounds to support super-large INSERT transactions on Android and resolve an issue with `/` character in Capacitor. It also includes premium improvements to the internal JSON interface between Javascript and native parts on Android, iOS, and macOS which improves the performance and resolves memory issues in case of some very large SQL batches and large SELECT results, with help from [`android-sqlite-evmax-ndk-driver-free`](https://github.com/brodybits/android-sqlite-evmax-ndk-driver-free) on Android.
 - This plugin version includes additional JavaScript performance enhancements with special benefit for Android.
 - This plugin version includes the following extra (non-standard) features: BASE 64 (all platforms Android/iOS/macOS/Windows), REGEXP (Android/iOS/macOS)
 - Using `SQLITE_DEFAULT_SYNCHRONOUS=3` (EXTRA DURABLE) build setting to be extra robust against possible database corruption ref: [xpbrew/cordova-sqlite-storage#736](https://github.com/xpbrew/cordova-sqlite-storage/issues/736)
@@ -575,7 +575,7 @@ See **Security of sensitive data** in the [Security](#security) section above.
 - 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 and less descriptive on Android in case of the default [`android-sqlite-evplus-ndk-driver-free`](https://github.com/storesafe/android-sqlite-evplus-ndk-driver-free) implementation.
+- SQL error messages are inconsistent on Windows and less descriptive on Android in case of the default [`android-sqlite-evmax-ndk-driver-free`](https://github.com/brodybits/android-sqlite-evmax-ndk-driver-free) implementation.
 - There are some other differences in the SQL error messages reported by WebKit Web SQL and this plugin.
 
 <!-- END Deviations -->
@@ -584,16 +584,16 @@ See **Security of sensitive data** in the [Security](#security) section above.
 
 - Possible crashes with certain cases of invalid binary string data on Android
 - 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
-- The default [`android-sqlite-evplus-ndk-driver-free`](https://github.com/storesafe/android-sqlite-evplus-ndk-driver-free) database access implementation does not currently handle control characters such as vertical tab, form feed, or backspace characters properly ref: [`storesafe/cordova-sqlite-evcore-extbuild-free#28`](https://github.com/storesafe/cordova-sqlite-evcore-extbuild-free/issues/28)
+- The default [`android-sqlite-evmax-ndk-driver-free`](https://github.com/brodybits/android-sqlite-evmax-ndk-driver-free) database access implementation does not currently handle control characters such as vertical tab, form feed, or backspace characters properly ref: [`storesafe/cordova-sqlite-evcore-extbuild-free#28`](https://github.com/storesafe/cordova-sqlite-evcore-extbuild-free/issues/28)
 - 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](https://github.com/xpbrew/cordova-sqlite-storage/issues/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.
 - FIXED in this plugin version: ~~Memory issue observed when adding a large number of records due to the JSON implementation which is improved in [storesafe / cordova-sqlite-evcore-extbuild-free](https://github.com/storesafe/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](https://github.com/xpbrew/cordova-sqlite-storage/issues/405)
 - A stability issue was reported on the iOS platform version when in use together with [SockJS](http://sockjs.org/) client such as [pusher-js](https://github.com/pusher/pusher-js) at the same time (see [xpbrew/cordova-sqlite-storage#196](https://github.com/xpbrew/cordova-sqlite-storage/issues/196)). The workaround is to call sqlite functions and [SockJS](http://sockjs.org/) client functions in separate ticks (using setTimeout with 0 timeout).
-- Hanging transactions in case of special JSON characters in result columns default [`android-sqlite-evplus-ndk-driver-free`](https://github.com/storesafe/android-sqlite-evplus-ndk-driver-free) database access implementation ref: [`storesafe/cordova-sqlite-evcore-extbuild-free#51`](https://github.com/storesafe/cordova-sqlite-evcore-extbuild-free/issues/51)
+- Hanging transactions in case of special JSON characters in result columns default [`android-sqlite-evmax-ndk-driver-free`](https://github.com/brodybits/android-sqlite-evmax-ndk-driver-free) database access implementation ref: [`storesafe/cordova-sqlite-evcore-extbuild-free#51`](https://github.com/storesafe/cordova-sqlite-evcore-extbuild-free/issues/51)
 - SQL errors are reported with incorrect & inconsistent error message on Windows - error message info not always correct, see also [storesafe/cordova-sqlite-storage#539](https://github.com/storesafe/cordova-sqlite-storage/issues/539)
-- Issue on default [`android-sqlite-evplus-ndk-driver-free`](https://github.com/storesafe/android-sqlite-evplus-ndk-driver-free) database access implementation in case of database file name with multi-byte UTF-8 characters ref: [litehelpers/Cordova-sqlite-evcore-extbuild-free#25](https://github.com/litehelpers/Cordova-sqlite-evcore-extbuild-free/issues/25)
-- Incorrect handling of NULL characters (`'\0\` or `'\u0000'`) on Android (default [`android-sqlite-evplus-ndk-driver-free`](https://github.com/storesafe/android-sqlite-evplus-ndk-driver-free) database access implementation) and Windows ref: [`storesafe/cordova-sqlite-evcore-extbuild-free#27`](https://github.com/storesafe/cordova-sqlite-evcore-extbuild-free/issues/27)
+- Issue on default [`android-sqlite-evmax-ndk-driver-free`](https://github.com/brodybits/android-sqlite-evmax-ndk-driver-free) database access implementation in case of database file name with multi-byte UTF-8 characters ref: [litehelpers/Cordova-sqlite-evcore-extbuild-free#25](https://github.com/litehelpers/Cordova-sqlite-evcore-extbuild-free/issues/25)
+- Incorrect handling of NULL characters (`'\0\` or `'\u0000'`) on Android (default [`android-sqlite-evmax-ndk-driver-free`](https://github.com/brodybits/android-sqlite-evmax-ndk-driver-free) database access implementation) and Windows ref: [`storesafe/cordova-sqlite-evcore-extbuild-free#27`](https://github.com/storesafe/cordova-sqlite-evcore-extbuild-free/issues/27)
 - 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.
@@ -614,7 +614,7 @@ Some additional issues are tracked in [open cordova-sqlite-storage bug-general i
 - 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](https://issues.apache.org/jira/browse/CB-9435) and [cordova/cordova-discuss#57](https://github.com/cordova/cordova-discuss/issues/57). This is fixed with a workaround for iOS/macOS in: [litehelpers / Cordova-sqlite-evplus-legacy-free](https://github.com/litehelpers/Cordova-sqlite-evplus-legacy-free) and [litehelpers / Cordova-sqlite-evplus-legacy-attach-detach-free](https://github.com/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](https://github.com/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 using BASE64 function (described elsewhere in this document) is supported by this plugin version (GPL or premium commercial license options, as documented above) as well as [`brodybits/cordova-sqlite-ext`](https://github.com/brodybits/cordova-sqlite-ext) (permissive license terms). INLINE BLOB values such as `X'010203'` are supported by the SQLite syntax on all platforms. FUTURE TBD equivalent to UNHEX (supported in MySQL) or conversion of Base-64 string to BLOB is desired.
-- Database files with certain multi-byte UTF-8 characters are not tested and not expected to work consistently across all platform implementations. The default [`android-sqlite-evplus-ndk-driver-free`](https://github.com/storesafe/android-sqlite-evplus-ndk-driver-free) database access implementation may not function properly on certain Android versions in case of database file names with emoji and other 4-byte UTF-8 characters ref: [storesafe/cordova-sqlite-evcore-extbuild-free#26](https://github.com/storesafe/cordova-sqlite-evcore-extbuild-free/issues/26)
+- Database files with certain multi-byte UTF-8 characters are not tested and not expected to work consistently across all platform implementations. The default [`android-sqlite-evmax-ndk-driver-free`](https://github.com/brodybits/android-sqlite-evmax-ndk-driver-free) database access implementation may not function properly on certain Android versions in case of database file names with emoji and other 4-byte UTF-8 characters ref: [storesafe/cordova-sqlite-evcore-extbuild-free#26](https://github.com/storesafe/cordova-sqlite-evcore-extbuild-free/issues/26)
 - Issues with UNICODE `\u0000` character (same as `\0`):
   - Truncation in case of argument value with UNICODE `\u0000` character reproduced on (WebKit) Web SQL; known issues with this plugin version as referenced above on Android (default `android-sqlite-evcore-native-driver-free` database access implementation) and Windows ([storesafe/cordova-sqlite-evcore-extbuild-free#27](https://github.com/storesafe/cordova-sqlite-evcore-extbuild-free/issues/27))
   - SQL error reported in case of inline value string with with UNICODE `\u0000` character on (WebKit) Web SQL, plugin on Android with use of the `androidDatabaseProvider: 'system'` setting, and plugin on _some_ other platforms
@@ -842,7 +842,7 @@ var db = window.sqlitePlugin.openDatabase({name: 'my.db', location: 'default'},
 
 **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 [android-sqlite-evplus-ndk-driver-free](https://github.com/storesafe/android-sqlite-evplus-ndk-driver-free) sqlite database access 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](https://github.com/xpbrew/cordova-sqlite-storage/issues/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.
+**WARNING 2:** As described above: by default this plugin uses a non-standard [`android-sqlite-evmax-ndk-driver-free`](https://github.com/brodybits/android-sqlite-evmax-ndk-driver-free) sqlite database access 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](https://github.com/xpbrew/cordova-sqlite-storage/issues/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*):
 
@@ -950,7 +950,7 @@ Use the `location` or `iosDatabaseLocation` option in `sqlitePlugin.openDatabase
 
 ### Android database provider
 
-By default, this plugin uses [android-sqlite-evplus-ndk-driver-free](https://github.com/storesafe/android-sqlite-evplus-ndk-driver-free) with the performance and memory usage enhancements. To use the built-in Android system database provider implementation instead:
+By default, this plugin uses [`android-sqlite-evmax-ndk-driver-free`](https://github.com/brodybits/android-sqlite-evmax-ndk-driver-free) with the performance and memory usage enhancements. To use the built-in Android system database provider implementation instead:
 
 ```js
 var db = window.sqlitePlugin.openDatabase({
@@ -963,7 +963,7 @@ var db = window.sqlitePlugin.openDatabase({
 (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-evplus-ndk-driver-free`](https://github.com/storesafe/android-sqlite-evplus-ndk-driver-free) database access 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](https://github.com/storesafe/cordova-sqlite-storage/issues/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.
+- As described above: by default this plugin uses a non-standard [`android-sqlite-evmax-ndk-driver-free`](https://github.com/brodybits/android-sqlite-evmax-ndk-driver-free) database access 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](https://github.com/storesafe/cordova-sqlite-storage/issues/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](https://github.com/xpbrew/cordova-sqlite-storage/issues/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.
 
 <!-- END Android database provider -->
@@ -976,7 +976,7 @@ var db = window.sqlitePlugin.openDatabase({
 
 The cause of this issue remains unknown. Of interest: [android / platform_external_sqlite commit d4f30d0d15](https://github.com/android/platform_external_sqlite/commit/d4f30d0d1544f8967ee5763c4a1680cb0553039f) 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-evplus-ndk-driver-free](https://github.com/storesafe/android-sqlite-evplus-ndk-driver-free) database implementation is used, which is the case when no `androidDatabaseProvider` or `androidDatabaseImplementation` setting is used.
+This is *not* an issue when the default [`android-sqlite-evmax-ndk-driver-free`](https://github.com/brodybits/android-sqlite-evmax-ndk-driver-free) 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:
 

package/SQLitePlugin.coffee.md

@@ -456,7 +456,8 @@
           t = typeof v
           flatlist.push(
             if v == null || v == undefined then null
-            else if t == 'number' || t == 'string' then v
+            else if t == 'number' then v
+            else if t == 'string' then v.replace('!', '!!').replace('/', '!|')
             else v.toString()
           )
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cordova-sqlite-evmax-build-free",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Cordova/PhoneGap sqlite storage - free evmax enterprise version with premium stability and performance improvements including workaround for super-large INSERT transactions & SELECT results on Android (version with external sqlite3 dependencies)",
   "cordova": {
     "id": "cordova-sqlite-evmax-common-free",

package/plugin.xml

@@ -2,7 +2,7 @@
 <plugin xmlns="http://www.phonegap.com/ns/plugins/1.0"
     xmlns:android="http://schemas.android.com/apk/res/android"
     id="cordova-sqlite-evmax-build-free"
-    version="0.0.6">
+    version="0.0.7">
 
     <name>Cordova sqlite storage - free evmax common version branch with premium stability performance improvements including workaround for super-large INSERT transactions and SELECT results on Android (with external sqlite3 dependencies)</name>
 
@@ -35,7 +35,7 @@
          -->
 
         <!-- JAR with NDK libs & Java JNI class -->
-        <lib-file src="src/deps/android/sqlc-evplus-ndk-driver.jar" />
+        <lib-file src="src/deps/android/sqlc-evmax-ndk-driver.jar" />
     </platform>
 
     <!-- iOS -->

package/spec/www/spec/db-tx-sql-select-value-test.js

@@ -1876,6 +1876,24 @@ var mytests = function() {
 
       });
 
+        it(suiteName + "SELECT UPPER(?) with ['/ab!cd'] parameter argument", function(done) {
+          var db = openDatabase('SELECT-UPPER-with-slash-ab-bang-cd-TEXT-string-argument.db');
+          expect(db).toBeDefined();
+          db.transaction(function(tx) {
+            tx.executeSql('SELECT UPPER(?) as myresult', ['/ab!cd'], function(ignored, rs) {
+              expect(rs).toBeDefined();
+              expect(rs.rows).toBeDefined();
+              expect(rs.rows.length).toBe(1);
+              expect(rs.rows.item(0).myresult).toBe('/AB!CD');
+              done();
+            });
+          }, function(error) {
+            expect(false).toBe(true);
+            expect(error.message).toBe('--');
+            done();
+          });
+        }, MYTIMEOUT);
+
     });
 
   }

package/spec/www/spec/sqlite-version-test.js

@@ -104,10 +104,7 @@ var mytests = function() {
               expect(rs).toBeDefined();
               expect(rs.rows).toBeDefined();
               expect(rs.rows.length).toBe(1);
-              if (isAndroid)
-                expect(rs.rows.item(0).myResult).toBe('3.38.5');
-              else
-                expect(rs.rows.item(0).myResult).toBe('3.40.0');
+              expect(rs.rows.item(0).myResult).toBe('3.40.0');
 
               // Close (plugin only) & finish:
               (isWebSql) ? done() : db.close(done, done);

package/src/android/io/sqlc/SQLitePlugin.java

@@ -391,7 +391,7 @@ public class SQLitePlugin extends CordovaPlugin {
         @Override
         void open(File dbFile) throws Exception {
             if (!isNativeLibLoaded) {
-                System.loadLibrary("sqlc-evplus-ndk-driver");
+                System.loadLibrary("sqlc-evmax-ndk-driver");
                 isNativeLibLoaded = true;
             }
 

package/www/SQLitePlugin.js

@@ -390,7 +390,7 @@ Contact for commercial license: sales@litehelpers.net
       for (l = 0, len1 = values.length; l < len1; l++) {
         v = values[l];
         t = typeof v;
-        flatlist.push(v === null || v === void 0 ? null : t === 'number' || t === 'string' ? v : v.toString());
+        flatlist.push(v === null || v === void 0 ? null : t === 'number' ? v : t === 'string' ? v.replace('!', '!!').replace('/', '!|') : v.toString());
       }
     } else {
       flatlist.push(0);