orange-orm 5.2.3 → 5.3.0

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;

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/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;
@@ -100,7 +101,7 @@ declare namespace r {
         date(): DateColumnDef;
     }
     export interface DateColumnDef {
-        validate(validator: (value?: Date | string, meta: ValidationMeta) => void): DateColumnDef;
+        validate(validator: (value?: Date | string, meta?: ValidationMeta) => void): DateColumnDef;
         notNull(): DateColumnNotNullDef;
         JSONSchema(schema: object, options?: Options): DateColumnDef;
         serializable(value: boolean): DateColumnDef;
@@ -110,7 +111,7 @@ declare namespace r {
     }
 
     export interface DateColumnNotNullDef {
-        validate(validator: (value: Date | string, meta: ValidationMeta) => void): DateColumnNotNullDef;
+        validate(validator: (value: Date | string, meta?: ValidationMeta) => void): DateColumnNotNullDef;
         JSONSchema(schema: object, options?: Options): DateColumnNotNullDef;
         serializable(value: boolean): DateColumnNotNullDef;
         as(dbName: string): DateColumnNotNullDef;
@@ -119,7 +120,7 @@ declare namespace r {
     }
 
     export interface BinaryColumnDef {
-        validate(validator: (value?: Buffer | string, meta: ValidationMeta) => void): BinaryColumnDef;
+        validate(validator: (value?: Buffer | string, meta?: ValidationMeta) => void): BinaryColumnDef;
         notNull(): BinaryColumnNotNullDef;
         JSONSchema(schema: object, options?: Options): BinaryColumnDef;
         serializable(value: boolean): BinaryColumnDef;
@@ -129,7 +130,7 @@ declare namespace r {
     }
 
     export interface BinaryColumnNotNullDef {
-        validate(validator: (value: Buffer | string, meta: ValidationMeta) => void): BinaryColumnNotNullDef;
+        validate(validator: (value: Buffer | string, meta?: ValidationMeta) => void): BinaryColumnNotNullDef;
         JSONSchema(schema: object, options?: Options): BinaryColumnNotNullDef;
         serializable(value: boolean): BinaryColumnNotNullDef;
         as(dbName: string): BinaryColumnNotNullDef;
@@ -138,7 +139,7 @@ declare namespace r {
     }
 
     export interface ColumnOf<T> {
-        validate(validator: (value?: T, meta: ValidationMeta) => void): ColumnOf<T>;
+        validate(validator: (value?: T, meta?: ValidationMeta) => void): ColumnOf<T>;
         notNull(): ColumnNotNullOf<T>;
         JSONSchema(schema: object, options?: Options): ColumnOf<T>;
         serializable(value: boolean): ColumnOf<T>;
@@ -148,7 +149,7 @@ declare namespace r {
     }
 
     export interface ColumnNotNullOf<T> {
-        validate(validator: (value: T, meta: ValidationMeta) => void): ColumnNotNullOf<T>;
+        validate(validator: (value: T, meta?: ValidationMeta) => void): ColumnNotNullOf<T>;
         notNull(): ColumnNotNullOf<T>;
         JSONSchema(schema: object, options?: Options): ColumnNotNullOf<T>;
         serializable(value: boolean): ColumnNotNullOf<T>;

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;
 }
 
@@ -659,90 +662,90 @@ interface ColumnType<M> {
 
 type UuidValidator<M> = M extends NotNull
 	? {
-		validate(validator: (value: string, meta: ValidationMeta) => void): UuidColumnTypeDef<M>;
+		validate(validator: (value: string, meta?: ValidationMeta) => void): UuidColumnTypeDef<M>;
 	}
 	: {
 		validate(
-			validator: (value?: string | null, meta: ValidationMeta) => void
+			validator: (value?: string | null, meta?: ValidationMeta) => void
 		): UuidColumnTypeDef<M>;
 	};
 type StringValidator<M> = M extends NotNull
 	? {
-		validate(validator: (value: string, meta: ValidationMeta) => void): StringColumnTypeDef<M>;
+		validate(validator: (value: string, meta?: ValidationMeta) => void): StringColumnTypeDef<M>;
 	}
 	: {
 		validate(
-			validator: (value?: string | null, meta: ValidationMeta) => void
+			validator: (value?: string | null, meta?: ValidationMeta) => void
 		): StringColumnTypeDef<M>;
 	};
 type NumericValidator<M> = M extends NotNull
 	? {
-		validate(validator: (value: number, meta: ValidationMeta) => void): NumericColumnTypeDef<M>;
+		validate(validator: (value: number, meta?: ValidationMeta) => void): NumericColumnTypeDef<M>;
 	}
 	: {
 		validate(
-			validator: (value?: number | null, meta: ValidationMeta) => void
+			validator: (value?: number | null, meta?: ValidationMeta) => void
 		): NumericColumnTypeDef<M>;
 	};
 type BigIntValidator<M> = M extends NotNull
 	? {
-		validate(validator: (value: bigint, meta: ValidationMeta) => void): BigIntColumnTypeDef<M>;
+		validate(validator: (value: bigint, meta?: ValidationMeta) => void): BigIntColumnTypeDef<M>;
 	}
 	: {
 		validate(
-			validator: (value?: bigint | null, meta: ValidationMeta) => void
+			validator: (value?: bigint | null, meta?: ValidationMeta) => void
 		): BigIntColumnTypeDef<M>;
 	};
 type BinaryValidator<M> = M extends NotNull
 	? {
-		validate(validator: (value: string, meta: ValidationMeta) => void): BinaryColumnTypeDef<M>;
+		validate(validator: (value: string, meta?: ValidationMeta) => void): BinaryColumnTypeDef<M>;
 	}
 	: {
 		validate(
-			validator: (value?: string | null, meta: ValidationMeta) => void
+			validator: (value?: string | null, meta?: ValidationMeta) => void
 		): BinaryColumnTypeDef<M>;
 	};
 type BooleanValidator<M> = M extends NotNull
 	? {
-		validate(validator: (value: boolean, meta: ValidationMeta) => void): BooleanColumnTypeDef<M>;
+		validate(validator: (value: boolean, meta?: ValidationMeta) => void): BooleanColumnTypeDef<M>;
 	}
 	: {
 		validate(
-			validator: (value?: boolean | null, meta: ValidationMeta) => void
+			validator: (value?: boolean | null, meta?: ValidationMeta) => void
 		): BooleanColumnTypeDef<M>;
 	};
 type JSONValidator<M> = M extends NotNull
 	? {
 		validate(
-			validator: (value: ToJsonType<M>, meta: ValidationMeta) => void
+			validator: (value: ToJsonType<M>, meta?: ValidationMeta) => void
 		): JSONColumnTypeDef<M>;
 	}
 	: {
 		validate(
-			validator: (value?: ToJsonType<M> | null, meta: ValidationMeta) => void
+			validator: (value?: ToJsonType<M> | null, meta?: ValidationMeta) => void
 		): JSONColumnTypeDef<M>;
 	};
 type DateValidator<M> = M extends NotNull
 	? {
 		validate(
-			validator: (value: string | Date, meta: ValidationMeta) => void
+			validator: (value: string | Date, meta?: ValidationMeta) => void
 		): DateColumnTypeDef<M>;
 	}
 	: {
 		validate(
-			validator: (value?: string | Date | null, meta: ValidationMeta) => void
+			validator: (value?: string | Date | null, meta?: ValidationMeta) => void
 		): DateColumnTypeDef<M>;
 	};
 
 type DateWithTimeZoneValidator<M> = M extends NotNull
 	? {
 		validate(
-			validator: (value: string | Date, meta: ValidationMeta) => void
+			validator: (value: string | Date, meta?: ValidationMeta) => void
 		): DateWithTimeZoneColumnTypeDef<M>;
 	}
 	: {
 		validate(
-			validator: (value?: string | Date | null, meta: ValidationMeta) => void
+			validator: (value?: string | Date | null, meta?: ValidationMeta) => void
 		): DateWithTimeZoneColumnTypeDef<M>;
 	};
 

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/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/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, '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, '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);

package/src/table/commands/delete/singleCommand/newSingleCommandCore.js

@@ -60,7 +60,7 @@ function newSingleCommandCore(context, table, filter, alias, concurrencyState) {
 		if (engine === 'pg') {
 			return newParameterized(columnSql + ' IS NOT DISTINCT FROM ' + encoded.sql(), encoded.parameters);
 		}
-		if (engine === 'mysql') {
+		if (engine === 'mysql' || engine === 'mariadb') {
 			return newParameterized(columnSql + ' <=> ' + encoded.sql(), encoded.parameters);
 		}
 		if (engine === 'sqlite') {
@@ -101,6 +101,10 @@ function newSingleCommandCore(context, table, filter, alias, concurrencyState) {
 			const jsonValue = JSON.stringify(value === undefined ? null : value);
 			return newParameterized('CAST(? AS JSON)', [jsonValue]);
 		}
+		if (engine === 'mariadb') {
+			const jsonValue = JSON.stringify(value === undefined ? null : value);
+			return newParameterized('JSON_EXTRACT(?, \'$\')', [jsonValue]);
+		}
 		if (engine === 'sqlite') {
 			if (isJsonObject(value)) {
 				const jsonValue = JSON.stringify(value);