orange-orm 5.2.4 → 5.3.1

package/docs/changelog.md

@@ -1,4 +1,9 @@
 ## Changelog
+__5.3.1__  
+Fixes crashes in getById/getMany when a missing relation has nested hasMany/hasOne/references in the strategy. [#177](https://github.com/alfateam/orange-orm/issues/177)  
+Added max parameter chunking for getManyDto hasMany subqueries on MSSQL, SQLite and Oracle.  
+__5.3.0__  
+Support for MariaDB [#169](https://github.com/alfateam/orange-orm/issues/169)  
 __5.2.4__  
 Meta parameter in validator is optional  
 __5.2.3__  

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "orange-orm",
-    "version": "5.2.4",
+    "version": "5.3.1",
     "publishConfig": {
         "access": "public"
     },
@@ -37,6 +37,7 @@
         "sap",
         "sapase",
         "Oracle",
+        "MariaDB",
         "rdb",
         "Orange ORM",
         "active record"

package/src/bunSqlite/newTransaction.js

@@ -19,6 +19,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {})  {
 		rdb.pool = pool;
 	}
 	rdb.engine = 'sqlite';
+	rdb.maxParameters = 32766;
 	rdb.encodeBoolean = encodeBoolean;
 	rdb.encodeBinary = encodeBinary;
 	rdb.decodeBinary = decodeBinary;
@@ -106,4 +107,4 @@ function decodeJSON(value) {
 	return JSON.parse(value);
 }
 
-module.exports = newResolveTransaction;
+module.exports = newResolveTransaction;

package/src/client/clientMap.js

@@ -37,6 +37,7 @@ function map(index, _fn) {
 	dbMap.mssql = throwDb;
 	dbMap.mssqlNative = throwDb;
 	dbMap.mysql = throwDb;
+	dbMap.mariadb = throwDb;
 	dbMap.sap = throwDb;
 	dbMap.oracle = throwDb;
 	dbMap.sqlite = throwDb;
@@ -65,6 +66,7 @@ function map(index, _fn) {
 	onFinal.mssql = () => index({ db: throwDb, providers: dbMap });
 	onFinal.mssqlNative = () => index({ db: throwDb, providers: dbMap });
 	onFinal.mysql = () => index({ db: throwDb, providers: dbMap });
+	onFinal.mariadb = () => index({ db: throwDb, providers: dbMap });
 	onFinal.sap = () => index({ db: throwDb, providers: dbMap });
 	onFinal.oracle = () => index({ db: throwDb, providers: dbMap });
 	onFinal.sqlite = () => index({ db: throwDb, providers: dbMap });

package/src/client/createProviders.js

@@ -38,6 +38,11 @@ function createProviders(index) {
 			return createPool.bind(null, 'mysql');
 		}
 	});
+	Object.defineProperty(dbMap, 'mariadb', {
+		get:  function() {
+			return createPool.bind(null, 'mariadb');
+		}
+	});
 	Object.defineProperty(dbMap, 'sap', {
 		get:  function() {
 			return createPool.bind(null, 'sap');
@@ -102,6 +107,9 @@ function negotiateCachedPool(fn, providers) {
 		get mysql() {
 			return createPool.bind(null, 'mysql');
 		},
+		get mariadb() {
+			return createPool.bind(null, 'mariadb');
+		},
 		get sap() {
 			return createPool.bind(null, 'sap');
 		},

package/src/client/index.js

@@ -65,6 +65,7 @@ function rdbClient(options = {}) {
 	client.oracle = onProvider.bind(null, 'oracle');
 	client.http = onProvider.bind(null, 'http');//todo
 	client.mysql = onProvider.bind(null, 'mysql');
+	client.mariadb = onProvider.bind(null, 'mariadb');
 	client.express = express;
 	client.hono = hono;
 	client.close = close;
@@ -1085,7 +1086,7 @@ function column(path, ...previous) {
 				if (arguments[i][isColumnProxyKey])
 					args[i] = { [columnRefKey]: arguments[i][columnPathKey] };
 				else
-					args[i] = arguments[i](tableProxy(path.split('.').slice(0, -1).join('.')));
+					args[i] = arguments[i](tableProxy());
 			}
 			else
 				args[i] = arguments[i];

package/src/client/map.js

@@ -46,6 +46,7 @@ function map(index, context, providers, fn) {
 	context.mssql = connect.bind(null, 'mssql');
 	context.mssqlNative = connect.bind(null, 'mssqlNative');
 	context.mysql = connect.bind(null, 'mysql');
+	context.mariadb = connect.bind(null, 'mariadb');
 	context.sap = connect.bind(null, 'sap');
 	context.oracle = connect.bind(null, 'oracle');
 	context.sqlite = connect.bind(null, 'sqlite');

package/src/getManyDto.js

@@ -126,16 +126,18 @@ async function decode(context, strategy, span, rows, keys = rows.length > 0 ? Ob
 			outRow[column.alias] = column.decode(context, row[keys[j]]);
 		}
 
-		for (let j = 0; j < aggregateKeys.length; j++) {
-			const key = aggregateKeys[j];
-			const parse = span.aggregates[key].column?.decode || ((context, arg) => Number.parseFloat(arg));
-			outRow[key] = parse(context, row[keys[j + columnsLength]]);
+		if (outRow) {
+			for (let j = 0; j < aggregateKeys.length; j++) {
+				const key = aggregateKeys[j];
+				const parse = span.aggregates[key].column?.decode || ((context, arg) => Number.parseFloat(arg));
+				outRow[key] = parse(context, row[keys[j + columnsLength]]);
+			}
 		}
 
 		outRows[i] = outRow;
 		if (updateParent)
 			updateParent(outRow, i);
-		if (shouldCreateMap) {
+		if (shouldCreateMap && outRow) {
 			fkIds[i] = getIds(outRow);
 			addToMap(rowsMap, fkIds[i], outRow);
 		}

package/src/index.d.ts

@@ -28,6 +28,7 @@ declare namespace r {
     function mssql(connectionString: string, options?: PoolOptions): Pool;
     function mssqlNative(connectionString: string, options?: PoolOptions): Pool;
     function mysql(connectionString: string, options?: PoolOptions): Pool;
+    function mariadb(connectionString: string, options?: PoolOptions): Pool;
     function oracle(config: PoolAttributes, options?: PoolOptions): Pool;
     function on(type: 'query', cb: (e: QueryEvent) => void): void;
     function off(type: 'query', cb: (e: QueryEvent) => void): void;

package/src/index.js

@@ -6,6 +6,7 @@ const map = require('./client/map');
 const runtimes = require('./runtimes');
 
 let _mySql;
+let _mariadb;
 let _pg;
 let _pglite;
 let _sqlite;
@@ -16,7 +17,9 @@ let _oracle;
 let _d1;
 
 var connectViaPool = function(connectionString) {
-	if (connectionString.indexOf && connectionString.indexOf('mysql') === 0)
+	if (connectionString.indexOf && connectionString.indexOf('mariadb') === 0)
+		return connectViaPool.mariadb.apply(null, arguments);
+	else if (connectionString.indexOf && connectionString.indexOf('mysql') === 0)
 		return connectViaPool.mySql.apply(null, arguments);
 	else if (connectionString.indexOf && connectionString.indexOf('postgres') === 0)
 		connectViaPool.pg.apply(null, arguments);
@@ -57,6 +60,13 @@ Object.defineProperty(connectViaPool, 'mySql', {
 		return _mySql;
 	}
 });
+Object.defineProperty(connectViaPool, 'mariadb', {
+	get: function() {
+		if (!_mariadb)
+			_mariadb = require('./mariaDb/newDatabase');
+		return _mariadb;
+	}
+});
 Object.defineProperty(connectViaPool, 'pglite', {
 	get: function() {
 		if (!_pglite)

package/src/map.d.ts

@@ -41,6 +41,7 @@ type DbConnectable<T> = {
 	mssql(connectionString: string, options?: PoolOptions): DBClient<SchemaFromMappedDb<T>>;
 	mssqlNative(connectionString: string, options?: PoolOptions): DBClient<SchemaFromMappedDb<T>>;
 	mysql(connectionString: string, options?: PoolOptions): DBClient<SchemaFromMappedDb<T>>;
+	mariadb(connectionString: string, options?: PoolOptions): DBClient<SchemaFromMappedDb<T>>;
 	oracle(config: PoolAttributes, options?: PoolOptions): DBClient<SchemaFromMappedDb<T>>;
 };
 
@@ -71,6 +72,8 @@ interface Connectors {
 	sap(connectionString: string, options?: PoolOptions): Pool;
 	mssql(connectionConfig: ConnectionConfiguration, options?: PoolOptions): Pool;
 	mssql(connectionString: string, options?: PoolOptions): Pool;
+	mysql(connectionString: string, options?: PoolOptions): Pool;
+	mariadb(connectionString: string, options?: PoolOptions): Pool;
 	oracle(config: PoolAttributes, options?: PoolOptions): Pool;
 }
 

package/src/map2.d.ts

@@ -881,6 +881,8 @@ interface Connectors {
   sap(connectionString: string, options?: PoolOptions): Pool;
   mssql(connectionConfig: ConnectionConfiguration, options?: PoolOptions): Pool;
   mssql(connectionString: string, options?: PoolOptions): Pool;
+  mysql(connectionString: string, options?: PoolOptions): Pool;
+  mariadb(connectionString: string, options?: PoolOptions): Pool;
   oracle(config: PoolAttributes, options?: PoolOptions): Pool;
 }
 
@@ -895,6 +897,7 @@ type DbConnectable<M extends Record<string, TableDefinition<M>>> = {
   mssql(connectionString: string, options?: PoolOptions): DBClient<M>;
   mssqlNative(connectionString: string, options?: PoolOptions): DBClient<M>;
   mysql(connectionString: string, options?: PoolOptions): DBClient<M>;
+  mariadb(connectionString: string, options?: PoolOptions): DBClient<M>;
   oracle(config: PoolAttributes, options?: PoolOptions): DBClient<M>;
 };
 

package/src/mariaDb/newDatabase.js

@@ -0,0 +1,101 @@
+let createDomain = require('../createDomain');
+let newTransaction = require('./newTransaction');
+let _begin = require('../table/begin');
+let commit = require('../table/commit');
+let rollback = require('../table/rollback');
+let newPool = require('./newPool');
+let express = require('../hostExpress');
+let hono = require('../hostHono');
+let hostLocal = require('../hostLocal');
+let doQuery = require('../query');
+let releaseDbClient = require('../table/releaseDbClient');
+
+function newDatabase(connectionString, poolOptions) {
+	if (!connectionString)
+		throw new Error('Connection string cannot be empty');
+	poolOptions = poolOptions || { min: 1 };
+	var pool = newPool(connectionString, poolOptions);
+
+	let c = { poolFactory: pool, hostLocal, express, hono };
+
+	c.transaction = function(options, fn) {
+		if ((arguments.length === 1) && (typeof options === 'function')) {
+			fn = options;
+			options = undefined;
+		}
+		let domain = createDomain();
+
+		if (!fn)
+			throw new Error('transaction requires a function');
+		return domain.run(runInTransaction);
+
+		async function runInTransaction() {
+			let result;
+			let transaction = newTransaction(domain, pool, options);
+			await new Promise(transaction)
+				.then(begin)
+				.then(() => fn(domain))
+				.then((res) => result = res)
+				.then(() => commit(domain))
+				.then(null, (e) => rollback(domain, e));
+			return result;
+		}
+
+		function begin() {
+			return _begin(domain, options);
+		}
+	};
+
+	c.createTransaction = function(options) {
+		let domain = createDomain();
+		let transaction = newTransaction(domain, pool);
+		let p = domain.run(() => new Promise(transaction).then(begin));
+
+		function run(fn) {
+			return p.then(() => fn(domain));
+		}
+		run.rollback = rollback.bind(null, domain);
+		run.commit = commit.bind(null, domain);
+		return run;
+
+		function begin() {
+			return _begin(domain, options);
+		}
+	};
+
+	c.query = function(query) {
+		let domain = createDomain();
+		let transaction = newTransaction(domain, pool);
+		let p = domain.run(() => new Promise(transaction)
+			.then(() => doQuery(domain, query).then(onResult, onError)));
+		return p;
+
+		function onResult(result) {
+			releaseDbClient(domain);
+			return result;
+		}
+
+		function onError(e) {
+			releaseDbClient(domain);
+			throw e;
+		}
+	};
+
+	c.rollback = rollback;
+	c.commit = commit;
+
+	c.end = function() {
+		if (poolOptions)
+			return pool.end();
+		else
+			return Promise.resolve();
+	};
+
+	c.accept = function(caller) {
+		caller.visitMySql();
+	};
+
+	return c;
+}
+
+module.exports = newDatabase;

package/src/mariaDb/newPool.js

@@ -0,0 +1,13 @@
+const mySqlNewPool = require('../mySql/newPool');
+
+function normalizeConnectionString(connectionString) {
+	if (typeof connectionString === 'string' && connectionString.indexOf('mariadb://') === 0)
+		return 'mysql://' + connectionString.slice('mariadb://'.length);
+	return connectionString;
+}
+
+function newPool(connectionString, poolOptions) {
+	return mySqlNewPool(normalizeConnectionString(connectionString), poolOptions);
+}
+
+module.exports = newPool;

package/src/mariaDb/newTransaction.js

@@ -0,0 +1,126 @@
+const wrapQuery = require('../mySql/wrapQuery');
+const wrapCommand = require('../mySql/wrapCommand');
+const encodeBoolean = require('../mySql/encodeBoolean');
+const deleteFromSql = require('../mySql/deleteFromSql');
+const selectForUpdateSql = require('../mySql/selectForUpdateSql');
+const lastInsertedSql = require('../mySql/lastInsertedSql');
+const limitAndOffset = require('../mySql/limitAndOffset');
+const formatBigintOut = require('../mySql/formatBigintOut');
+const insertSql = require('../mySql/insertSql');
+const insert = require('../mySql/insert');
+const quote = require('../mySql/quote');
+
+function newResolveTransaction(domain, pool, { readonly = false } = {}) {
+	var rdb = { poolFactory: pool };
+	if (!pool.connect) {
+		pool = pool();
+		rdb.pool = pool;
+	}
+	rdb.engine = 'mariadb';
+	rdb.encodeBoolean = encodeBoolean;
+	rdb.decodeJSON = decodeJSON;
+	rdb.encodeDate = encodeDate;
+	rdb.encodeDateTz = encodeDateTz;
+	rdb.encodeJSON = JSON.stringify;
+	rdb.deleteFromSql = deleteFromSql;
+	rdb.selectForUpdateSql = selectForUpdateSql;
+	rdb.lastInsertedIsSeparate = true;
+	rdb.lastInsertedSql = lastInsertedSql;
+	rdb.formatBigintOut = formatBigintOut;
+	rdb.insertSql = insertSql;
+	rdb.insert = insert;
+	rdb.multipleStatements = false;
+	rdb.limitAndOffset = limitAndOffset;
+	rdb.accept = function(caller) {
+		caller.visitMySql();
+	};
+	rdb.aggregateCount = 0;
+	rdb.quote = quote;
+	rdb.cache = {};
+	rdb.changes = [];
+
+	if (readonly) {
+		rdb.dbClient = {
+			executeQuery: function(query, callback) {
+				pool.connect((err, client, done) => {
+					if (err) {
+						return callback(err);
+					}
+					try {
+						wrapQuery(domain, client)(query, (err, res) => {
+							done();
+							callback(err, res);
+						});
+					} catch (e) {
+						done();
+						callback(e);
+					}
+				});
+			},
+			executeCommand: function(query, callback) {
+				pool.connect((err, client, done) => {
+					if (err) {
+						return callback(err);
+					}
+					try {
+						wrapCommand(domain, client)(query, (err, res) => {
+							done();
+							callback(err, res);
+						});
+					} catch (e) {
+						done();
+						callback(e);
+					}
+				});
+			}
+		};
+		domain.rdb = rdb;
+		return (onSuccess) => onSuccess();
+	}
+
+	return function(onSuccess, onError) {
+		pool.connect(onConnected);
+
+		function onConnected(err, client, done) {
+			try {
+				if (err) {
+					onError(err);
+					return;
+				}
+				client.executeQuery = wrapQuery(domain, client);
+				client.executeCommand = wrapCommand(domain, client);
+				rdb.dbClient = client;
+				rdb.dbClientDone = done;
+				domain.rdb = rdb;
+				onSuccess();
+			} catch (e) {
+				onError(e);
+			}
+		}
+	};
+}
+
+function decodeJSON(value) {
+	return JSON.parse(value);
+}
+
+function encodeDate(date) {
+	date = date.toISOString ? removeTimezone(date.toISOString()) : removeTimezone(date);
+	return date;
+}
+
+function removeTimezone(isoString) {
+	let dateTimePattern = /[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(.[0-9]{3})?/;
+	let match = isoString.match(dateTimePattern);
+	return match ? match[0] : isoString;
+}
+
+function encodeDateTz(date) {
+	if (date && date.toISOString)
+		return removeTimezone(date.toISOString());
+	if (typeof date === 'string' && /(Z|[+-][0-9]{2}:[0-9]{2})$/.test(date))
+		return removeTimezone(new Date(date).toISOString());
+	return date;
+}
+
+module.exports = newResolveTransaction;

package/src/mssql/newTransaction.js

@@ -19,6 +19,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 		rdb.pool = pool;
 	}
 	rdb.engine = 'mssqlNative';
+	rdb.maxParameters = 2100;
 	rdb.encodeBoolean = encodeBoolean;
 	rdb.decodeJSON = decodeJSON;
 	rdb.encodeJSON = JSON.stringify;
@@ -117,4 +118,4 @@ function decodeJSON(value){
 	return JSON.parse(value);
 }
 
-module.exports = newResolveTransaction;
+module.exports = newResolveTransaction;

package/src/mySql/newTransaction.js

@@ -18,6 +18,9 @@ function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 	}
 	rdb.engine = 'mysql';
 	rdb.encodeBoolean = encodeBoolean;
+	rdb.decodeJSON = decodeJSON;
+	rdb.encodeDate = encodeDate;
+	rdb.encodeDateTz = encodeDateTz;
 	rdb.encodeJSON = JSON.stringify;
 	rdb.deleteFromSql = deleteFromSql;
 	rdb.selectForUpdateSql = selectForUpdateSql;
@@ -97,4 +100,27 @@ function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 	};
 }
 
-module.exports = newResolveTransaction;
+function decodeJSON(value) {
+	return JSON.parse(value);
+}
+
+function encodeDate(date) {
+	date = date.toISOString ? removeTimezone(date.toISOString()) : removeTimezone(date);
+	return date;
+}
+
+function removeTimezone(isoString) {
+	let dateTimePattern = /[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(.[0-9]{3})?/;
+	let match = isoString.match(dateTimePattern);
+	return match ? match[0] : isoString;
+}
+
+function encodeDateTz(date) {
+	if (date && date.toISOString)
+		return removeTimezone(date.toISOString());
+	if (typeof date === 'string' && /(Z|[+-][0-9]{2}:[0-9]{2})$/.test(date))
+		return removeTimezone(new Date(date).toISOString());
+	return date;
+}
+
+module.exports = newResolveTransaction;

package/src/nodeSqlite/newTransaction.js

@@ -19,6 +19,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {})  {
 		rdb.pool = pool;
 	}
 	rdb.engine = 'sqlite';
+	rdb.maxParameters = 32766;
 	rdb.encodeBoolean = encodeBoolean;
 	rdb.encodeBinary = encodeBinary;
 	rdb.decodeBinary = decodeBinary;
@@ -106,4 +107,4 @@ function decodeJSON(value) {
 	return JSON.parse(value);
 }
 
-module.exports = newResolveTransaction;
+module.exports = newResolveTransaction;

package/src/oracle/newTransaction.js

@@ -21,6 +21,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 
 	rdb.begin = 'SET TRANSACTION ISOLATION LEVEL READ COMMITTED';
 	rdb.engine = 'oracle';
+	rdb.maxParameters = 32768;
 	rdb.encodeBoolean = encodeBoolean;
 	rdb.decodeJSON = decodeJSON;
 	rdb.encodeJSON = JSON.stringify;
@@ -110,4 +111,4 @@ function decodeJSON(value) {
 	return JSON.parse(value);
 }
 
-module.exports = newResolveTransaction;
+module.exports = newResolveTransaction;

package/src/patchTable.js

@@ -267,8 +267,6 @@ async function patchTableCore(context, table, patches, { strategy = undefined, d
 			let result;
 			for (let i = 0; i < relation.columns.length; i++) {
 				let p = relation.columns[i].alias;
-				let dto = {};
-				dto[p] = row[p];
 				result = await remove({ path: ['dummy', p], oldValue: (oldValue || {})[p], op, options: options }, table, row) || result;
 			}
 			return result || {};
@@ -281,9 +279,7 @@ async function patchTableCore(context, table, patches, { strategy = undefined, d
 				let p = relation.columns[i].alias;
 				let childKey = relation.childTable._primaryColumns[i].alias;
 				if (path[1] === childKey) {
-					let dto = {};
-					dto[p] = row[p];
-					result = await remove({ path: ['dummy', p], oldValue: (oldValue || {})[p], op, options: options }, table, row) || result;
+					result = await remove({ path: ['dummy', p], oldValue: oldValue[p], op, options: options }, table, row) || result;
 					break;
 				}
 			}

package/src/pg/pool/newPgPool.js

@@ -22,7 +22,7 @@ function newPgPool(connectionString, poolOptions) {
 				if (!pg) {
 					pg = await import('pg');
 					pg  = pg.default || pg;
-					let types = pg.types || pg.types;
+					let types = pg.types;
 					types.setTypeParser(1700, function(val) {
 						return parseFloat(val);
 					});

package/src/sqlite3/newTransaction.js

@@ -17,6 +17,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {})  {
 		rdb.pool = pool;
 	}
 	rdb.engine = 'sqlite';
+	rdb.maxParameters = 32766;
 	rdb.encodeBoolean = encodeBoolean;
 	rdb.decodeJSON = decodeJSON;
 	rdb.encodeJSON = JSON.stringify;
@@ -102,4 +103,4 @@ function decodeJSON(value) {
 	return JSON.parse(value);
 }
 
-module.exports = newResolveTransaction;
+module.exports = newResolveTransaction;

package/src/table/column/bigint/newEncode.js

@@ -21,7 +21,7 @@ function _new(column) {
 		value = purify(value);
 		if (value == null) {
 			if (column.dbNull === null)
-				'null';
+				return 'null';
 			return '\'' + column.dbNull + '\'';
 		}
 		var encodeCore = getSessionSingleton(context, 'encodeBigint') || encodeBigint;

package/src/table/column/date/newEncode.js

@@ -21,7 +21,7 @@ function _new(column) {
 		value = purify(value);
 		if (value == null) {
 			if (column.dbNull === null)
-				'null';
+				return 'null';
 			return '\'' + column.dbNull + '\'';
 		}
 		var encodeCore = getSessionSingleton(context, 'encodeDate') || encodeDate;

package/src/table/column/dateWithTimeZone/newEncode.js

@@ -1,38 +1,43 @@
 var newPara = require('../../query/newParameterized');
 var purify = require('../date/purify');
+var getSessionContext = require('../../getSessionContext');
+var getSessionSingleton = require('../../getSessionSingleton');
 
 function _new(column) {
-	var encode = function(_context, value) {
+	var encode = function(context, value) {
 		value = purify(value);
 		if (value == null) {
 			if (column.dbNull === null)
 				return newPara('null');
 			return newPara('\'' + column.dbNull + '\'');
 		}
-		return newPara('?', [encodeDate(value)]);
+		var ctx = getSessionContext(context);
+		var encodeCore = ctx.encodeDateTz || ctx.encodeDate || encodeDate;
+		return newPara('?', [encodeCore(value)]);
 	};
 
-	encode.unsafe = function(_context, value) {
+	encode.unsafe = function(context, value) {
 		value = purify(value);
 		if (value == null) {
 			if (column.dbNull === null)
 				return 'null';
 			return '\'' + column.dbNull + '\'';
 		}
-		return encodeDate(value);
+		var encodeCore = getSessionSingleton(context, 'encodeDateTz') || getSessionSingleton(context, 'encodeDate') || encodeDate;
+		return encodeCore(value);
 	};
 
-	encode.direct = function(_context, value) {
-		return encodeDate(value);
+	encode.direct = function(context, value) {
+		var encodeCore = getSessionSingleton(context, 'encodeDateTz') || getSessionSingleton(context, 'encodeDate') || encodeDate;
+		return encodeCore(value);
 	};
 
 	return encode;
-
-
 }
+
 function encodeDate(date) {
 	if (date.toISOString)
-		return truncate(date.toISOString(date));
+		return truncate(date.toISOString());
 	return truncate(date);
 }
 
@@ -40,5 +45,4 @@ function truncate(date) {
 	return date;
 }
 
-
 module.exports = _new;

package/src/table/column/string/newLikeColumnArg.js

@@ -6,7 +6,7 @@ function newLikeColumnArg(context, column, encodedArg, prefix, suffix) {
 	var encodedSuffix = suffix ? column.encode(context, suffix) : null;
 	var engine = getSessionSingleton(context, 'engine');
 
-	if (engine === 'mysql')
+	if (engine === 'mysql' || engine === 'mariadb')
 		return concatWithFunction(encodedPrefix, encodedArg, encodedSuffix);
 	if (engine === 'mssql' || engine === 'mssqlNative')
 		return concatWithOperator('+', encodedPrefix, encodedArg, encodedSuffix);