@relq/orm 0.1.3 → 0.1.4

package/dist/cjs/mysql/condition/condition-collector.cjs

@@ -0,0 +1,377 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlConditionCollector = void 0;
+exports.buildMysqlConditionSQL = buildMysqlConditionSQL;
+exports.buildMysqlConditionsSQL = buildMysqlConditionsSQL;
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+const json_condition_builder_1 = require("./json-condition-builder.cjs");
+const json_path_proxy_1 = require("./json-path-proxy.cjs");
+const fulltext_condition_builder_1 = require("./fulltext-condition-builder.cjs");
+class MysqlConditionCollector {
+    conditions = [];
+    _tables;
+    _tableName;
+    _fulltext;
+    get json() {
+        return (0, json_path_proxy_1.createMysqlJsonColumnProxy)(this);
+    }
+    get fulltext() {
+        if (!this._fulltext) {
+            this._fulltext = new fulltext_condition_builder_1.MysqlFulltextConditionCollector(this);
+        }
+        return this._fulltext;
+    }
+    equal(column, value) {
+        this.conditions.push({ method: 'equal', column, values: value });
+        return this;
+    }
+    notEqual(column, value) {
+        this.conditions.push({ method: 'notEqual', column, values: value });
+        return this;
+    }
+    lessThan(column, value) {
+        this.conditions.push({ method: 'lessThan', column, values: value });
+        return this;
+    }
+    lessThanEqual(column, value) {
+        this.conditions.push({ method: 'lessThanEqual', column, values: value });
+        return this;
+    }
+    greaterThan(column, value) {
+        this.conditions.push({ method: 'greaterThan', column, values: value });
+        return this;
+    }
+    greaterThanEqual(column, value) {
+        this.conditions.push({ method: 'greaterThanEqual', column, values: value });
+        return this;
+    }
+    isNull(column) {
+        this.conditions.push({ method: 'isNull', column });
+        return this;
+    }
+    isNotNull(column) {
+        this.conditions.push({ method: 'isNotNull', column });
+        return this;
+    }
+    between(column, start, end) {
+        this.conditions.push({ method: 'between', column, values: [start, end] });
+        return this;
+    }
+    notBetween(column, start, end) {
+        this.conditions.push({ method: 'notBetween', column, values: [start, end] });
+        return this;
+    }
+    startsWith(column, value, caseInsensitive) {
+        this.conditions.push({
+            method: caseInsensitive ? 'startsWithI' : 'startsWith',
+            column,
+            values: value
+        });
+        return this;
+    }
+    notStartsWith(column, value, caseInsensitive) {
+        this.conditions.push({
+            method: caseInsensitive ? 'notStartsWithI' : 'notStartsWith',
+            column,
+            values: value
+        });
+        return this;
+    }
+    endsWith(column, value, caseInsensitive) {
+        this.conditions.push({
+            method: caseInsensitive ? 'endsWithI' : 'endsWith',
+            column,
+            values: value
+        });
+        return this;
+    }
+    notEndsWith(column, value, caseInsensitive) {
+        this.conditions.push({
+            method: caseInsensitive ? 'notEndsWithI' : 'notEndsWith',
+            column,
+            values: value
+        });
+        return this;
+    }
+    contains(column, value, caseInsensitive) {
+        this.conditions.push({
+            method: caseInsensitive ? 'containsI' : 'contains',
+            column,
+            values: value
+        });
+        return this;
+    }
+    notContains(column, value, caseInsensitive) {
+        this.conditions.push({
+            method: caseInsensitive ? 'notContainsI' : 'notContains',
+            column,
+            values: value
+        });
+        return this;
+    }
+    like(column, pattern) {
+        this.conditions.push({ method: 'like', column, values: pattern });
+        return this;
+    }
+    notLike(column, pattern) {
+        this.conditions.push({ method: 'notLike', column, values: pattern });
+        return this;
+    }
+    ilike(column, pattern) {
+        this.conditions.push({ method: 'ilike', column, values: pattern });
+        return this;
+    }
+    notIlike(column, pattern) {
+        this.conditions.push({ method: 'notIlike', column, values: pattern });
+        return this;
+    }
+    regex(column, pattern) {
+        this.conditions.push({ method: 'regex', column, values: pattern });
+        return this;
+    }
+    iregex(column, pattern) {
+        this.conditions.push({ method: 'iregex', column, values: pattern });
+        return this;
+    }
+    notRegex(column, pattern) {
+        this.conditions.push({ method: 'notRegex', column, values: pattern });
+        return this;
+    }
+    notIregex(column, pattern) {
+        this.conditions.push({ method: 'notIregex', column, values: pattern });
+        return this;
+    }
+    isTrue(column) {
+        this.conditions.push({ method: 'isTrue', column });
+        return this;
+    }
+    isFalse(column) {
+        this.conditions.push({ method: 'isFalse', column });
+        return this;
+    }
+    nullSafeEqual(column, value) {
+        this.conditions.push({ method: 'nullSafeEqual', column, values: value });
+        return this;
+    }
+    nullSafeNotEqual(column, value) {
+        this.conditions.push({ method: 'nullSafeNotEqual', column, values: value });
+        return this;
+    }
+    search(column, value) {
+        this.conditions.push({ method: 'search', column, values: value });
+        return this;
+    }
+    notSearch(column, value) {
+        this.conditions.push({ method: 'notSearch', column, values: value });
+        return this;
+    }
+    greaterThanOrEqual(column, value) {
+        return this.greaterThanEqual(column, value);
+    }
+    lessThanOrEqual(column, value) {
+        return this.lessThanEqual(column, value);
+    }
+    notNull(column) {
+        return this.isNotNull(column);
+    }
+    in(column, values) {
+        if (typeof values === 'function') {
+            const subquery = values(this._tables);
+            this.conditions.push({ method: 'in', column, values: subquery.toString() });
+        }
+        else if (!Array.isArray(values) && typeof values === 'object' && values !== null && 'toString' in values) {
+            this.conditions.push({ method: 'in', column, values: values.toString() });
+        }
+        else {
+            this.conditions.push({ method: 'in', column, values });
+        }
+        return this;
+    }
+    notIn(column, values) {
+        if (typeof values === 'function') {
+            const subquery = values(this._tables);
+            this.conditions.push({ method: 'notIn', column, values: subquery.toString() });
+        }
+        else if (!Array.isArray(values) && typeof values === 'object' && values !== null && 'toString' in values) {
+            this.conditions.push({ method: 'notIn', column, values: values.toString() });
+        }
+        else {
+            this.conditions.push({ method: 'notIn', column, values });
+        }
+        return this;
+    }
+    exists(subquery) {
+        this.conditions.push({ method: 'exists', values: subquery });
+        return this;
+    }
+    notExists(subquery) {
+        this.conditions.push({ method: 'notExists', values: subquery });
+        return this;
+    }
+    or(callback) {
+        const subBuilder = new MysqlConditionCollector();
+        callback(subBuilder);
+        this.conditions.push({ method: 'or', values: subBuilder.getConditions() });
+        return this;
+    }
+    and(callback) {
+        const subBuilder = new MysqlConditionCollector();
+        callback(subBuilder);
+        this.conditions.push({ method: 'and', values: subBuilder.getConditions() });
+        return this;
+    }
+    not(callback) {
+        const subBuilder = new MysqlConditionCollector();
+        callback(subBuilder);
+        this.conditions.push({ method: 'not', values: subBuilder.getConditions() });
+        return this;
+    }
+    getConditions() {
+        return this.conditions;
+    }
+}
+exports.MysqlConditionCollector = MysqlConditionCollector;
+function formatColumn(column) {
+    if (column.includes('.')) {
+        const parts = column.split('.');
+        return parts.map(p => mysql_format_1.default.ident(p)).join('.');
+    }
+    return mysql_format_1.default.ident(column);
+}
+function buildMysqlConditionSQL(condition) {
+    const { method, column, values } = condition;
+    if (method === 'mysql_json_proxy') {
+        return (0, json_path_proxy_1.buildMysqlJsonProxySQL)(condition);
+    }
+    if (method.startsWith('json_')) {
+        return (0, json_condition_builder_1.buildMysqlJsonConditionSQL)(condition);
+    }
+    if (method.startsWith('fulltext_')) {
+        return (0, fulltext_condition_builder_1.buildMysqlFulltextConditionSQL)(condition);
+    }
+    const col = column ? formatColumn(column) : '';
+    switch (method) {
+        case 'equal':
+            if (Array.isArray(values) && values.length > 1) {
+                return `${col} IN ${mysql_format_1.default.literal(values)}`;
+            }
+            return `${col} = ${mysql_format_1.default.literal(Array.isArray(values) ? values[0] : values)}`;
+        case 'notEqual':
+            if (Array.isArray(values) && values.length > 1) {
+                return `${col} NOT IN ${mysql_format_1.default.literal(values)}`;
+            }
+            return `${col} != ${mysql_format_1.default.literal(Array.isArray(values) ? values[0] : values)}`;
+        case 'lessThan':
+            return `${col} < ${mysql_format_1.default.literal(Array.isArray(values) ? values[0] : values)}`;
+        case 'lessThanEqual':
+            return `${col} <= ${mysql_format_1.default.literal(Array.isArray(values) ? values[0] : values)}`;
+        case 'greaterThan':
+            return `${col} > ${mysql_format_1.default.literal(Array.isArray(values) ? values[0] : values)}`;
+        case 'greaterThanEqual':
+            return `${col} >= ${mysql_format_1.default.literal(Array.isArray(values) ? values[0] : values)}`;
+        case 'isNull':
+            return `${col} IS NULL`;
+        case 'isNotNull':
+            return `${col} IS NOT NULL`;
+        case 'between': {
+            const [start, end] = values;
+            return `${col} BETWEEN ${mysql_format_1.default.literal(start)} AND ${mysql_format_1.default.literal(end)}`;
+        }
+        case 'notBetween': {
+            const [notStart, notEnd] = values;
+            return `${col} NOT BETWEEN ${mysql_format_1.default.literal(notStart)} AND ${mysql_format_1.default.literal(notEnd)}`;
+        }
+        case 'startsWith':
+            return `${col} LIKE ${mysql_format_1.default.literal(`${values}%`)}`;
+        case 'startsWithI':
+            return `LOWER(${col}) LIKE LOWER(${mysql_format_1.default.literal(`${values}%`)})`;
+        case 'notStartsWith':
+            return `${col} NOT LIKE ${mysql_format_1.default.literal(`${values}%`)}`;
+        case 'notStartsWithI':
+            return `LOWER(${col}) NOT LIKE LOWER(${mysql_format_1.default.literal(`${values}%`)})`;
+        case 'endsWith':
+            return `${col} LIKE ${mysql_format_1.default.literal(`%${values}`)}`;
+        case 'endsWithI':
+            return `LOWER(${col}) LIKE LOWER(${mysql_format_1.default.literal(`%${values}`)})`;
+        case 'notEndsWith':
+            return `${col} NOT LIKE ${mysql_format_1.default.literal(`%${values}`)}`;
+        case 'notEndsWithI':
+            return `LOWER(${col}) NOT LIKE LOWER(${mysql_format_1.default.literal(`%${values}`)})`;
+        case 'contains':
+            return `${col} LIKE ${mysql_format_1.default.literal(`%${values}%`)}`;
+        case 'containsI':
+            return `LOWER(${col}) LIKE LOWER(${mysql_format_1.default.literal(`%${values}%`)})`;
+        case 'notContains':
+            return `${col} NOT LIKE ${mysql_format_1.default.literal(`%${values}%`)}`;
+        case 'notContainsI':
+            return `LOWER(${col}) NOT LIKE LOWER(${mysql_format_1.default.literal(`%${values}%`)})`;
+        case 'like':
+            return `${col} LIKE ${mysql_format_1.default.literal(values)}`;
+        case 'notLike':
+            return `${col} NOT LIKE ${mysql_format_1.default.literal(values)}`;
+        case 'ilike':
+            return `LOWER(${col}) LIKE LOWER(${mysql_format_1.default.literal(values)})`;
+        case 'notIlike':
+            return `LOWER(${col}) NOT LIKE LOWER(${mysql_format_1.default.literal(values)})`;
+        case 'regex':
+            return `REGEXP_LIKE(${col}, ${mysql_format_1.default.literal(values)}, 'c')`;
+        case 'iregex':
+            return `REGEXP_LIKE(${col}, ${mysql_format_1.default.literal(values)}, 'i')`;
+        case 'notRegex':
+            return `NOT REGEXP_LIKE(${col}, ${mysql_format_1.default.literal(values)}, 'c')`;
+        case 'notIregex':
+            return `NOT REGEXP_LIKE(${col}, ${mysql_format_1.default.literal(values)}, 'i')`;
+        case 'isTrue':
+            return `${col} IS TRUE`;
+        case 'isFalse':
+            return `${col} IS FALSE`;
+        case 'nullSafeEqual':
+            return `${col} <=> ${mysql_format_1.default.literal(values)}`;
+        case 'nullSafeNotEqual':
+            return `NOT (${col} <=> ${mysql_format_1.default.literal(values)})`;
+        case 'search':
+            return `MATCH(${col}) AGAINST(${mysql_format_1.default.literal(values)} IN NATURAL LANGUAGE MODE)`;
+        case 'notSearch':
+            return `NOT MATCH(${col}) AGAINST(${mysql_format_1.default.literal(values)} IN NATURAL LANGUAGE MODE)`;
+        case 'in': {
+            if (typeof values === 'string') {
+                return `${col} IN (${values})`;
+            }
+            const valueList = Array.isArray(values) ? values : [values];
+            const formattedValues = valueList.map(v => mysql_format_1.default.literal(v)).join(', ');
+            return `${col} IN (${formattedValues})`;
+        }
+        case 'notIn': {
+            if (typeof values === 'string') {
+                return `${col} NOT IN (${values})`;
+            }
+            const valueList = Array.isArray(values) ? values : [values];
+            const formattedValues = valueList.map(v => mysql_format_1.default.literal(v)).join(', ');
+            return `${col} NOT IN (${formattedValues})`;
+        }
+        case 'exists':
+            return `EXISTS (${values})`;
+        case 'notExists':
+            return `NOT EXISTS (${values})`;
+        case 'or': {
+            const orConditions = values;
+            return `(${orConditions.map(c => buildMysqlConditionSQL(c)).join(' OR ')})`;
+        }
+        case 'and': {
+            const andConditions = values;
+            return `(${andConditions.map(c => buildMysqlConditionSQL(c)).join(' AND ')})`;
+        }
+        case 'not': {
+            const notConditions = values;
+            return `NOT (${notConditions.map(c => buildMysqlConditionSQL(c)).join(' AND ')})`;
+        }
+        default:
+            return '';
+    }
+}
+function buildMysqlConditionsSQL(conditions) {
+    return conditions.map(condition => buildMysqlConditionSQL(condition)).join(' AND ');
+}

package/dist/cjs/mysql/condition/fulltext-condition-builder.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlFulltextConditionCollector = void 0;
+exports.buildMysqlFulltextConditionSQL = buildMysqlFulltextConditionSQL;
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+class MysqlFulltextConditionCollector {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    match(column, query) {
+        this.parent.conditions.push({
+            method: 'fulltext_match',
+            column: Array.isArray(column) ? column.join(',') : column,
+            values: { query, mode: 'natural' }
+        });
+        return this.parent;
+    }
+    matchBoolean(column, query) {
+        this.parent.conditions.push({
+            method: 'fulltext_match',
+            column: Array.isArray(column) ? column.join(',') : column,
+            values: { query, mode: 'boolean' }
+        });
+        return this.parent;
+    }
+    matchExpansion(column, query) {
+        this.parent.conditions.push({
+            method: 'fulltext_match',
+            column: Array.isArray(column) ? column.join(',') : column,
+            values: { query, mode: 'expansion' }
+        });
+        return this.parent;
+    }
+}
+exports.MysqlFulltextConditionCollector = MysqlFulltextConditionCollector;
+function buildMysqlFulltextConditionSQL(condition) {
+    const { method, column, values } = condition;
+    switch (method) {
+        case 'fulltext_match': {
+            const { query, mode } = values;
+            const columns = column.includes(',')
+                ? column.split(',').map(c => mysql_format_1.default.ident(c.trim())).join(', ')
+                : mysql_format_1.default.ident(column);
+            const escapedQuery = mysql_format_1.default.literal(query);
+            switch (mode) {
+                case 'natural':
+                    return `MATCH(${columns}) AGAINST(${escapedQuery} IN NATURAL LANGUAGE MODE)`;
+                case 'boolean':
+                    return `MATCH(${columns}) AGAINST(${escapedQuery} IN BOOLEAN MODE)`;
+                case 'expansion':
+                    return `MATCH(${columns}) AGAINST(${escapedQuery} WITH QUERY EXPANSION)`;
+                default:
+                    return `MATCH(${columns}) AGAINST(${escapedQuery})`;
+            }
+        }
+        default:
+            return '';
+    }
+}

package/dist/cjs/mysql/condition/index.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMysqlFulltextConditionSQL = exports.MysqlFulltextConditionCollector = exports.buildMysqlJsonProxySQL = exports.createMysqlJsonColumnProxy = exports.buildMysqlJsonConditionSQL = exports.MysqlJsonConditionCollector = exports.buildMysqlConditionsSQL = exports.buildMysqlConditionSQL = exports.MysqlConditionCollector = void 0;
+var condition_collector_1 = require("./condition-collector.cjs");
+Object.defineProperty(exports, "MysqlConditionCollector", { enumerable: true, get: function () { return condition_collector_1.MysqlConditionCollector; } });
+Object.defineProperty(exports, "buildMysqlConditionSQL", { enumerable: true, get: function () { return condition_collector_1.buildMysqlConditionSQL; } });
+Object.defineProperty(exports, "buildMysqlConditionsSQL", { enumerable: true, get: function () { return condition_collector_1.buildMysqlConditionsSQL; } });
+var json_condition_builder_1 = require("./json-condition-builder.cjs");
+Object.defineProperty(exports, "MysqlJsonConditionCollector", { enumerable: true, get: function () { return json_condition_builder_1.MysqlJsonConditionCollector; } });
+Object.defineProperty(exports, "buildMysqlJsonConditionSQL", { enumerable: true, get: function () { return json_condition_builder_1.buildMysqlJsonConditionSQL; } });
+var json_path_proxy_1 = require("./json-path-proxy.cjs");
+Object.defineProperty(exports, "createMysqlJsonColumnProxy", { enumerable: true, get: function () { return json_path_proxy_1.createMysqlJsonColumnProxy; } });
+Object.defineProperty(exports, "buildMysqlJsonProxySQL", { enumerable: true, get: function () { return json_path_proxy_1.buildMysqlJsonProxySQL; } });
+var fulltext_condition_builder_1 = require("./fulltext-condition-builder.cjs");
+Object.defineProperty(exports, "MysqlFulltextConditionCollector", { enumerable: true, get: function () { return fulltext_condition_builder_1.MysqlFulltextConditionCollector; } });
+Object.defineProperty(exports, "buildMysqlFulltextConditionSQL", { enumerable: true, get: function () { return fulltext_condition_builder_1.buildMysqlFulltextConditionSQL; } });

package/dist/cjs/mysql/condition/json-condition-builder.cjs

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlJsonConditionCollector = void 0;
+exports.buildMysqlJsonConditionSQL = buildMysqlJsonConditionSQL;
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+class MysqlJsonConditionCollector {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    contains(column, value) {
+        this.parent.conditions.push({
+            method: 'json_contains',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    notContains(column, value) {
+        this.parent.conditions.push({
+            method: 'json_not_contains',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    overlaps(column, value) {
+        this.parent.conditions.push({
+            method: 'json_overlaps',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    extract(column, path, value) {
+        this.parent.conditions.push({
+            method: 'json_extract',
+            column,
+            values: { path, value }
+        });
+        return this.parent;
+    }
+    extractEqual(column, path, value) {
+        return this.extract(column, path, value);
+    }
+    extractGreaterThan(column, path, value) {
+        this.parent.conditions.push({
+            method: 'json_extract_gt',
+            column,
+            values: { path, value }
+        });
+        return this.parent;
+    }
+    extractLessThan(column, path, value) {
+        this.parent.conditions.push({
+            method: 'json_extract_lt',
+            column,
+            values: { path, value }
+        });
+        return this.parent;
+    }
+    extractIn(column, path, values) {
+        this.parent.conditions.push({
+            method: 'json_extract_in',
+            column,
+            values: { path, inValues: values }
+        });
+        return this.parent;
+    }
+    hasKey(column, key) {
+        this.parent.conditions.push({
+            method: 'json_has_key',
+            column,
+            values: key
+        });
+        return this.parent;
+    }
+    length(column, length) {
+        this.parent.conditions.push({
+            method: 'json_length',
+            column,
+            values: length
+        });
+        return this.parent;
+    }
+    typeIs(column, path, jsonType) {
+        this.parent.conditions.push({
+            method: 'json_type_is',
+            column,
+            values: { path, jsonType }
+        });
+        return this.parent;
+    }
+}
+exports.MysqlJsonConditionCollector = MysqlJsonConditionCollector;
+function buildMysqlJsonConditionSQL(condition) {
+    const { method, column, values } = condition;
+    const col = column ? mysql_format_1.default.ident(column) : '';
+    switch (method) {
+        case 'json_contains':
+            return `JSON_CONTAINS(${col}, ${mysql_format_1.default.literal(JSON.stringify(values))})`;
+        case 'json_not_contains':
+            return `NOT JSON_CONTAINS(${col}, ${mysql_format_1.default.literal(JSON.stringify(values))})`;
+        case 'json_overlaps':
+            return `JSON_OVERLAPS(${col}, ${mysql_format_1.default.literal(JSON.stringify(values))})`;
+        case 'json_extract': {
+            const { path, value } = values;
+            if (typeof value === 'number' || typeof value === 'boolean' || value === null) {
+                return `JSON_EXTRACT(${col}, ${mysql_format_1.default.literal(path)}) = ${mysql_format_1.default.literal(value)}`;
+            }
+            return `JSON_UNQUOTE(JSON_EXTRACT(${col}, ${mysql_format_1.default.literal(path)})) = ${mysql_format_1.default.literal(value)}`;
+        }
+        case 'json_extract_gt': {
+            const { path: gtPath, value: gtValue } = values;
+            return `JSON_EXTRACT(${col}, ${mysql_format_1.default.literal(gtPath)}) > ${mysql_format_1.default.literal(gtValue)}`;
+        }
+        case 'json_extract_lt': {
+            const { path: ltPath, value: ltValue } = values;
+            return `JSON_EXTRACT(${col}, ${mysql_format_1.default.literal(ltPath)}) < ${mysql_format_1.default.literal(ltValue)}`;
+        }
+        case 'json_extract_in': {
+            const { path: inPath, inValues } = values;
+            const formattedValues = inValues.map(v => mysql_format_1.default.literal(v)).join(', ');
+            return `JSON_UNQUOTE(JSON_EXTRACT(${col}, ${mysql_format_1.default.literal(inPath)})) IN (${formattedValues})`;
+        }
+        case 'json_has_key': {
+            const key = values;
+            return `JSON_EXTRACT(${col}, ${mysql_format_1.default.literal(`$.${key}`)}) IS NOT NULL`;
+        }
+        case 'json_length': {
+            const length = values;
+            return `JSON_LENGTH(${col}) = ${length}`;
+        }
+        case 'json_type_is': {
+            const { path, jsonType } = values;
+            return `JSON_TYPE(JSON_EXTRACT(${col}, ${mysql_format_1.default.literal(path)})) = ${mysql_format_1.default.literal(jsonType)}`;
+        }
+        default:
+            return '';
+    }
+}