uql-orm 0.9.3 → 0.9.5

package/dist/dialect/abstractSqlDialect.js

@@ -1,1332 +0,0 @@
-import { getMeta } from '../entity/index.js';
-import { resolveVectorCast } from '../schema/canonicalType.js';
-import { QueryRaw, RAW_ALIAS, RAW_VALUE, } from '../type/index.js';
-import { buildQueryWhereAsMap, buildSortMap, escapeSqlId, fillOnFields, filterFieldKeys, flatObject, getFieldCallbackValue, getFieldKeys, getKeys, getRelationRequestSummary, hasKeys, isJsonType, isPopulatingRelations, isVectorSearch, normalizeScalarFieldSelection, parseGroupMap, parseRelationAtKey, raw, } from '../util/index.js';
-import { AbstractDialect } from './abstractDialect.js';
-import { SqlQueryContext } from './queryContext.js';
-export class AbstractSqlDialect extends AbstractDialect {
-    constructor(engineDefaults, options = {}) {
-        super(engineDefaults, options);
-    }
-    isolationLevelStrategy = 'inline';
-    alterColumnStrategy = 'single-statement';
-    alterColumnSyntax = 'ALTER COLUMN';
-    dropForeignKeySyntax = 'DROP CONSTRAINT';
-    dropIndexSyntax = 'standalone';
-    renameTableSyntax = 'alter-table';
-    booleanLiteral = 'native';
-    vectorOpsClass = undefined;
-    vectorExtension = undefined;
-    get escapeIdChar() {
-        return this.quoteChar;
-    }
-    getBeginTransactionStatements(isolationLevel) {
-        const level = isolationLevel?.toUpperCase();
-        const strategy = this.isolationLevelStrategy;
-        if (!level || strategy === 'none') {
-            return [this.beginTransactionCommand];
-        }
-        if (strategy === 'inline') {
-            return [`${this.beginTransactionCommand} ISOLATION LEVEL ${level}`];
-        }
-        // 'set-before' — MySQL/MariaDB pattern
-        return [`SET TRANSACTION ISOLATION LEVEL ${level}`, this.beginTransactionCommand];
-    }
-    createContext() {
-        return new SqlQueryContext(this);
-    }
-    addValue(values, value) {
-        values.push(this.normalizeValue(value));
-        return this.placeholder(values.length);
-    }
-    /**
-     * Normalizes a parameter value for the database driver.
-     * Handles bigint, boolean, and serializes plain objects/arrays to JSON strings.
-     * Date values are preserved so SQL drivers can apply native date/time binding.
-     * Postgres overrides to pass objects through to its native JSONB driver.
-     */
-    normalizeValue(value) {
-        if (value == null || value instanceof Date || value instanceof Uint8Array || value instanceof QueryRaw) {
-            return value;
-        }
-        if (typeof value === 'bigint') {
-            return Number(value);
-        }
-        if (typeof value === 'boolean') {
-            return this.booleanLiteral === 'native' ? value : value ? 1 : 0;
-        }
-        return value;
-    }
-    /**
-     * Normalizes a list of parameter values.
-     */
-    normalizeValues(values) {
-        return values?.map((v) => this.normalizeValue(v));
-    }
-    placeholder(_index) {
-        return '?';
-    }
-    returningId(entity) {
-        const meta = getMeta(entity);
-        const idKey = (meta.id ?? 'id');
-        const idName = this.resolveColumnName(idKey, meta.fields[idKey]);
-        return `RETURNING ${this.escapeId(idName)} ${this.escapeId('id')}`;
-    }
-    search(ctx, entity, q = {}, opts = {}) {
-        const meta = getMeta(entity);
-        const tableName = this.resolveTableName(entity, meta);
-        const prefix = this.resolveRelationAwarePrefix(tableName, meta, opts, q.$select, q.$populate);
-        opts = { ...opts, prefix };
-        this.where(ctx, entity, q.$where, opts);
-        this.sort(ctx, entity, q.$sort, opts);
-        this.pager(ctx, q);
-    }
-    selectFields(ctx, entity, select, opts = {}, exclude) {
-        const meta = getMeta(entity);
-        const prefix = opts.prefix ? opts.prefix + '.' : '';
-        const escapedPrefix = this.escapeId(opts.prefix, true, true);
-        let selectArr;
-        if (select) {
-            if (Array.isArray(select)) {
-                // Internal-only path: raw SQL expressions passed as QueryRaw[]
-                selectArr = select;
-            }
-            else {
-                selectArr = normalizeScalarFieldSelection(meta, select, exclude);
-            }
-            const id = meta.id;
-            if (id && opts.prefix && !selectArr.includes(id)) {
-                selectArr = [id, ...selectArr];
-            }
-        }
-        else {
-            selectArr = normalizeScalarFieldSelection(meta, undefined, exclude);
-        }
-        if (!selectArr.length) {
-            ctx.append(escapedPrefix + '*');
-            return;
-        }
-        selectArr.forEach((key, index) => {
-            if (index > 0)
-                ctx.append(', ');
-            if (key instanceof QueryRaw) {
-                this.getRawValue(ctx, {
-                    value: key,
-                    prefix: opts.prefix,
-                    escapedPrefix,
-                    autoPrefixAlias: opts.autoPrefixAlias,
-                });
-            }
-            else {
-                const field = meta.fields[key];
-                if (!field)
-                    return;
-                const columnName = this.resolveColumnName(key, field);
-                if (field.virtual) {
-                    this.getRawValue(ctx, {
-                        value: raw(field.virtual[RAW_VALUE], key),
-                        prefix: opts.prefix,
-                        escapedPrefix,
-                        autoPrefixAlias: opts.autoPrefixAlias,
-                    });
-                }
-                else {
-                    ctx.append(escapedPrefix + this.escapeId(columnName));
-                }
-                if (!field.virtual && (columnName !== key || opts.autoPrefixAlias)) {
-                    const aliasStr = prefix + key;
-                    ctx.append(' ' + this.escapeId(aliasStr, true));
-                }
-            }
-        });
-    }
-    select(ctx, entity, select, exclude, populate, opts = {}, distinct, sort) {
-        const meta = getMeta(entity);
-        const tableName = this.resolveTableName(entity, meta);
-        const mapSelect = Array.isArray(select) ? undefined : select;
-        const prefix = this.resolveRelationAwarePrefix(tableName, meta, opts, mapSelect, populate);
-        ctx.append(distinct ? 'SELECT DISTINCT ' : 'SELECT ');
-        this.selectFields(ctx, entity, select, { prefix }, exclude);
-        // Add related fields BEFORE FROM clause
-        this.selectRelationFields(ctx, entity, mapSelect, populate, { prefix });
-        // Inject vector distance projections when $project is set
-        if (sort) {
-            const sortMap = buildSortMap(sort);
-            for (const [key, val] of Object.entries(sortMap)) {
-                if (isVectorSearch(val) && val.$project) {
-                    ctx.append(', ');
-                    this.appendVectorProjection(ctx, meta, key, val);
-                }
-            }
-        }
-        ctx.append(` FROM ${this.escapeId(tableName)}`);
-        // Add JOINs AFTER FROM clause
-        this.selectRelationJoins(ctx, entity, mapSelect, populate, { prefix });
-    }
-    resolveRelationAwarePrefix(tableName, meta, opts, select, populate) {
-        return (opts.prefix ?? (opts.autoPrefix || isPopulatingRelations(meta, populate))) ? tableName : undefined;
-    }
-    selectRelationFields(ctx, entity, select, populate, opts = {}) {
-        this.forEachJoinableRelation(entity, select, populate, opts, (relEntity, relQuery, joinRelAlias) => {
-            ctx.append(', ');
-            this.selectFields(ctx, relEntity, relQuery.$select, { prefix: joinRelAlias, autoPrefixAlias: true }, relQuery.$exclude);
-            this.selectRelationFields(ctx, relEntity, relQuery.$select, relQuery.$populate, { prefix: joinRelAlias });
-        });
-    }
-    selectRelationJoins(ctx, entity, select, populate, opts = {}) {
-        this.forEachJoinableRelation(entity, select, populate, opts, (relEntity, relQuery, joinRelAlias, relOpts, meta, tableName, required) => {
-            const relMeta = getMeta(relEntity);
-            const relTableName = this.resolveTableName(relEntity, relMeta);
-            const relEntityName = this.escapeId(relTableName);
-            const relPath = opts.prefix ? this.escapeId(opts.prefix, true) : this.escapeId(tableName);
-            const joinType = required ? 'INNER' : 'LEFT';
-            const joinAlias = this.escapeId(joinRelAlias, true);
-            ctx.append(` ${joinType} JOIN ${relEntityName} ${joinAlias} ON `);
-            let refAppended = false;
-            for (const it of relOpts.references ?? []) {
-                if (refAppended)
-                    ctx.append(' AND ');
-                const relField = relMeta.fields[it.foreign];
-                const field = meta.fields[it.local];
-                const foreignColumnName = this.resolveColumnName(it.foreign, relField);
-                const localColumnName = this.resolveColumnName(it.local, field);
-                ctx.append(`${joinAlias}.${this.escapeId(foreignColumnName)} = ${relPath}.${this.escapeId(localColumnName)}`);
-                refAppended = true;
-            }
-            if (relQuery.$where) {
-                ctx.append(' AND ');
-                this.where(ctx, relEntity, relQuery.$where, { prefix: joinRelAlias, clause: false });
-            }
-            this.selectRelationJoins(ctx, relEntity, relQuery.$select, relQuery.$populate, { prefix: joinRelAlias });
-        });
-    }
-    /**
-     * Iterates over joinable (11/m1) relations for a given select, resolving shared metadata.
-     * Used by both `selectRelationFields` and `selectRelationJoins` to avoid duplicated iteration logic.
-     */
-    forEachJoinableRelation(entity, select, populate, opts, callback) {
-        if (!select && !populate)
-            return;
-        const meta = getMeta(entity);
-        const tableName = this.resolveTableName(entity, meta);
-        const relKeys = getRelationRequestSummary(meta, populate).joinableKeys;
-        const prefix = opts.prefix;
-        for (const relKey of relKeys) {
-            const relOpts = meta.relations[relKey];
-            if (!relOpts?.entity)
-                continue;
-            const isFirstLevel = prefix === tableName;
-            const joinRelAlias = isFirstLevel ? relKey : prefix ? `${prefix}.${relKey}` : relKey;
-            const relEntity = relOpts.entity();
-            const { query: relQuery, required } = parseRelationAtKey(relKey, populate);
-            callback(relEntity, relQuery, joinRelAlias, relOpts, meta, tableName, required);
-        }
-    }
-    where(ctx, entity, where = {}, opts = {}) {
-        const meta = getMeta(entity);
-        const { usePrecedence, clause = 'WHERE', softDelete } = opts;
-        where = buildQueryWhereAsMap(meta, where);
-        if (meta.softDelete &&
-            (softDelete || softDelete === undefined) &&
-            !where[meta.softDelete]) {
-            where[meta.softDelete] = null;
-        }
-        const entries = Object.entries(where);
-        if (!entries.length) {
-            return;
-        }
-        if (clause) {
-            ctx.append(` ${clause} `);
-        }
-        if (usePrecedence) {
-            ctx.append('(');
-        }
-        const whereKeys = getKeys(where);
-        const hasMultipleKeys = whereKeys.length > 1;
-        let appended = false;
-        whereKeys.forEach((key) => {
-            const val = where[key];
-            if (val === undefined)
-                return;
-            if (appended) {
-                ctx.append(' AND ');
-            }
-            this.compare(ctx, entity, key, val, {
-                ...opts,
-                usePrecedence: hasMultipleKeys,
-            });
-            appended = true;
-        });
-        if (usePrecedence) {
-            ctx.append(')');
-        }
-    }
-    compare(ctx, entity, key, val, opts = {}) {
-        const meta = getMeta(entity);
-        if (val instanceof QueryRaw) {
-            if (key === '$exists' || key === '$nexists') {
-                ctx.append(key === '$exists' ? 'EXISTS (' : 'NOT EXISTS (');
-                const tableName = this.resolveTableName(entity, meta);
-                this.getRawValue(ctx, {
-                    value: val,
-                    prefix: tableName,
-                    escapedPrefix: this.escapeId(tableName, false, true),
-                });
-                ctx.append(')');
-                return;
-            }
-            this.getComparisonKey(ctx, entity, key, opts);
-            ctx.append(' = ');
-            this.getRawValue(ctx, { value: val });
-            return;
-        }
-        if (key === '$text') {
-            const search = val;
-            const searchFields = search.$fields ?? getFieldKeys(meta.fields);
-            const fields = searchFields.map((fKey) => {
-                const field = meta.fields[fKey];
-                const columnName = this.resolveColumnName(fKey, field);
-                return this.escapeId(columnName);
-            });
-            ctx.append(`MATCH(${fields.join(', ')}) AGAINST(`);
-            ctx.addValue(search.$value);
-            ctx.append(')');
-            return;
-        }
-        if (key === '$and' || key === '$or' || key === '$not' || key === '$nor') {
-            this.compareLogicalOperator(ctx, entity, key, val, opts);
-            return;
-        }
-        // Detect JSONB dot-notation: 'column.path' where column is a registered JSON/JSONB field
-        const jsonDot = this.resolveJsonDotPath(meta, key, opts.prefix);
-        if (jsonDot) {
-            this.compareJsonPath(ctx, jsonDot, val);
-            return;
-        }
-        if (key.includes('.')) {
-            throw new TypeError(`path ${key} does not exist in ${meta.name}`);
-        }
-        // Detect relation filtering
-        const rel = meta.relations[key];
-        if (rel) {
-            // Check if this is a $size query on a relation (count filtering)
-            const valObj = val;
-            if (valObj && typeof valObj === 'object' && '$size' in valObj && Object.keys(valObj).length === 1) {
-                this.compareRelationSize(ctx, entity, key, valObj['$size'], rel, opts);
-                return;
-            }
-            this.compareRelation(ctx, entity, key, val, rel, opts);
-            return;
-        }
-        const value = this.normalizeWhereValue(val);
-        const operators = getKeys(value);
-        if (operators.length > 1) {
-            ctx.append('(');
-        }
-        operators.forEach((op, index) => {
-            if (index > 0) {
-                ctx.append(' AND ');
-            }
-            this.compareFieldOperator(ctx, entity, key, op, value[op], opts);
-        });
-        if (operators.length > 1) {
-            ctx.append(')');
-        }
-    }
-    compareLogicalOperator(ctx, entity, key, val, opts) {
-        const op = AbstractSqlDialect.NEGATE_OP_MAP[key] ?? key;
-        const negate = key in AbstractSqlDialect.NEGATE_OP_MAP ? 'NOT' : '';
-        const valArr = val ?? [];
-        const hasManyItems = valArr.length > 1;
-        if ((opts.usePrecedence || negate) && hasManyItems) {
-            ctx.append((negate ? negate + ' ' : '') + '(');
-        }
-        else if (negate) {
-            ctx.append(negate + ' ');
-        }
-        valArr.forEach((whereEntry, index) => {
-            if (index > 0) {
-                ctx.append(op === '$or' ? ' OR ' : ' AND ');
-            }
-            if (whereEntry instanceof QueryRaw) {
-                this.getRawValue(ctx, {
-                    value: whereEntry,
-                });
-            }
-            else if (whereEntry) {
-                this.where(ctx, entity, whereEntry, {
-                    prefix: opts.prefix,
-                    usePrecedence: hasManyItems && !Array.isArray(whereEntry) && Object.keys(whereEntry).length > 1,
-                    clause: false,
-                });
-            }
-        });
-        if ((opts.usePrecedence || negate) && hasManyItems) {
-            ctx.append(')');
-        }
-    }
-    /** Simple comparison operators: `getComparisonKey → op → addValue`. */
-    static NEGATE_OP_MAP = { $not: '$and', $nor: '$or' };
-    static COMPARE_OP_MAP = {
-        $gt: ' > ',
-        $gte: ' >= ',
-        $lt: ' < ',
-        $lte: ' <= ',
-    };
-    static LIKE_OP_MAP = {
-        $startsWith: (v) => `${v}%`,
-        $istartsWith: (v) => `${v.toLowerCase()}%`,
-        $endsWith: (v) => `%${v}`,
-        $iendsWith: (v) => `%${v.toLowerCase()}`,
-        $includes: (v) => `%${v}%`,
-        $iincludes: (v) => `%${v.toLowerCase()}%`,
-        $like: (v) => v,
-        $ilike: (v) => v.toLowerCase(),
-    };
-    // biome-ignore lint/suspicious/noExplicitAny: method works with any entity type
-    resolveColumnWithPrefix(entity, key, { prefix } = {}) {
-        const meta = getMeta(entity);
-        const field = meta.fields[key];
-        const columnName = this.resolveColumnName(key, field);
-        const escapedPrefix = this.escapeId(prefix, true, true);
-        return escapedPrefix + this.escapeId(columnName);
-    }
-    /**
-     * Resolves the SQL operand for a field comparison.
-     * For QueryRaw virtuals, appends the raw expression to ctx and returns undefined.
-     */
-    resolveOperandField(ctx, 
-    // biome-ignore lint/suspicious/noExplicitAny: method works with any entity type
-    entity, key, opts) {
-        const col = getMeta(entity).fields[key];
-        if (col?.virtual) {
-            if (col.virtual instanceof QueryRaw) {
-                // biome-ignore lint/suspicious/noExplicitAny: field key type erased at runtime
-                this.getComparisonKey(ctx, entity, key, opts);
-                return undefined;
-            }
-            return `(${col.virtual})`;
-        }
-        return this.resolveColumnWithPrefix(entity, key, opts);
-    }
-    appendFieldSql(ctx, field, sql) {
-        ctx.append(field ? `${field}${sql}` : sql);
-    }
-    compareFieldOperator(ctx, entity, key, op, val, opts = {}) {
-        const field = this.resolveOperandField(ctx, entity, key, opts);
-        const simpleOp = AbstractSqlDialect.COMPARE_OP_MAP[op];
-        if (simpleOp) {
-            this.appendFieldSql(ctx, field, `${simpleOp}${this.addValue(ctx.values, val)}`);
-            return;
-        }
-        const likeWrap = AbstractSqlDialect.LIKE_OP_MAP[op];
-        if (likeWrap) {
-            this.appendLikeOp(ctx, field, op, likeWrap(val));
-            return;
-        }
-        switch (op) {
-            case '$eq':
-            case '$ne':
-                this.appendEqNe(ctx, field, op, val);
-                break;
-            case '$regex':
-                this.appendFieldSql(ctx, field, ` ${this.regexpOp} ${this.addValue(ctx.values, val)}`);
-                break;
-            case '$not':
-                ctx.append('NOT (');
-                this.compare(ctx, entity, key, val, opts);
-                ctx.append(')');
-                break;
-            case '$in':
-            case '$nin':
-                this.appendInNin(ctx, field, op, val);
-                break;
-            case '$between': {
-                const col = this.resolveColumnWithPrefix(entity, key, opts);
-                const [min, max] = val;
-                ctx.append(`${col} BETWEEN ${this.addValue(ctx.values, min)} AND ${this.addValue(ctx.values, max)}`);
-                break;
-            }
-            case '$isNull':
-                this.appendFieldSql(ctx, field, val ? ' IS NULL' : ' IS NOT NULL');
-                break;
-            case '$isNotNull':
-                this.appendFieldSql(ctx, field, val ? ' IS NOT NULL' : ' IS NULL');
-                break;
-            case '$all':
-                ctx.append(this.jsonAll(ctx, field ?? '', val));
-                break;
-            case '$size':
-                ctx.append(this.jsonSize(ctx, field ?? '', val));
-                break;
-            case '$elemMatch':
-                ctx.append(this.jsonElemMatch(ctx, field ?? '', val));
-                break;
-            default:
-                throw TypeError(`unknown operator: ${op}`);
-        }
-    }
-    appendLikeOp(ctx, field, op, wrappedVal) {
-        const isIlike = op.startsWith('$i') || op === '$ilike';
-        const ph = this.addValue(ctx.values, wrappedVal);
-        if (isIlike && field) {
-            ctx.append(this.ilikeExpr(field, ph));
-        }
-        else {
-            this.appendFieldSql(ctx, field, ` ${this.likeFn} ${ph}`);
-        }
-    }
-    appendEqNe(ctx, field, op, val) {
-        if (val === null) {
-            this.appendFieldSql(ctx, field, op === '$eq' ? ' IS NULL' : ' IS NOT NULL');
-            return;
-        }
-        const ph = this.addValue(ctx.values, val);
-        if (op === '$eq') {
-            this.appendFieldSql(ctx, field, ` = ${ph}`);
-            return;
-        }
-        if (field) {
-            ctx.append(this.neExpr(field, ph));
-        }
-        else {
-            this.appendFieldSql(ctx, field, ` ${this.neOp} ${ph}`);
-        }
-    }
-    appendInNin(ctx, field, op, val) {
-        this.appendFieldSql(ctx, field, this.formatIn(ctx, Array.isArray(val) ? val : [], op === '$nin'));
-    }
-    addValues(ctx, vals) {
-        vals.forEach((val, index) => {
-            if (index > 0) {
-                ctx.append(', ');
-            }
-            ctx.addValue(val);
-        });
-    }
-    /**
-     * Build a comparison condition for a JSON field.
-     * Used by both `$elemMatch` and dot-notation paths.
-     * All dialect-specific behavior comes from overridable methods on `this`.
-     */
-    buildJsonFieldCondition(ctx, fieldAccessor, jsonPath, op, value) {
-        const jsonField = fieldAccessor(jsonPath);
-        switch (op) {
-            case '$eq':
-                return value === null ? `${jsonField} IS NULL` : `${jsonField} = ${this.addValue(ctx.values, value)}`;
-            case '$ne':
-                if (value === null)
-                    return `${jsonField} IS NOT NULL`;
-                return this.neExpr(jsonField, this.addValue(ctx.values, value));
-            case '$gt':
-                return `${this.numericCast(jsonField)} > ${this.addValue(ctx.values, value)}`;
-            case '$gte':
-                return `${this.numericCast(jsonField)} >= ${this.addValue(ctx.values, value)}`;
-            case '$lt':
-                return `${this.numericCast(jsonField)} < ${this.addValue(ctx.values, value)}`;
-            case '$lte':
-                return `${this.numericCast(jsonField)} <= ${this.addValue(ctx.values, value)}`;
-            case '$like':
-                return `${jsonField} ${this.likeFn} ${this.addValue(ctx.values, value)}`;
-            case '$ilike':
-                return this.ilikeExpr(jsonField, this.addValue(ctx.values, value.toLowerCase()));
-            case '$startsWith':
-                return `${jsonField} ${this.likeFn} ${this.addValue(ctx.values, `${value}%`)}`;
-            case '$istartsWith':
-                return this.ilikeExpr(jsonField, this.addValue(ctx.values, `${value.toLowerCase()}%`));
-            case '$endsWith':
-                return `${jsonField} ${this.likeFn} ${this.addValue(ctx.values, `%${value}`)}`;
-            case '$iendsWith':
-                return this.ilikeExpr(jsonField, this.addValue(ctx.values, `%${value.toLowerCase()}`));
-            case '$includes':
-                return `${jsonField} ${this.likeFn} ${this.addValue(ctx.values, `%${value}%`)}`;
-            case '$iincludes':
-                return this.ilikeExpr(jsonField, this.addValue(ctx.values, `%${value.toLowerCase()}%`));
-            case '$regex':
-                return `${jsonField} ${this.regexpOp} ${this.addValue(ctx.values, value)}`;
-            case '$in':
-            case '$nin':
-                return this.jsonInNin(ctx, jsonField, op, value);
-            case '$all':
-                return this.jsonAll(ctx, jsonField, value);
-            case '$size':
-                return this.jsonSize(ctx, jsonField, value);
-            case '$elemMatch':
-                return this.jsonElemMatch(ctx, jsonField, value);
-            default:
-                throw TypeError(`unknown operator: ${op}`);
-        }
-    }
-    jsonInNin(ctx, jsonField, op, value) {
-        return `${jsonField}${this.formatIn(ctx, Array.isArray(value) ? value : [], op === '$nin')}`;
-    }
-    jsonAll(ctx, jsonField, value) {
-        throw TypeError(`$all is not supported in the base SQL dialect - override in dialect subclass`);
-    }
-    jsonSize(ctx, jsonField, value) {
-        throw TypeError(`$size is not supported in the base SQL dialect - override in dialect subclass`);
-    }
-    jsonElemMatch(ctx, jsonField, value) {
-        throw TypeError(`$elemMatch is not supported in the base SQL dialect - override in dialect subclass`);
-    }
-    isJsonbOp(op) {
-        return op === '$all' || op === '$size' || op === '$elemMatch';
-    }
-    getComparisonKey(ctx, entity, key, { prefix } = {}) {
-        const meta = getMeta(entity);
-        const escapedPrefix = this.escapeId(prefix, true, true);
-        const field = meta.fields[key];
-        if (field?.virtual) {
-            this.getRawValue(ctx, {
-                value: field.virtual,
-                prefix,
-                escapedPrefix,
-            });
-            return;
-        }
-        const columnName = this.resolveColumnName(key, field);
-        ctx.append(escapedPrefix + this.escapeId(columnName));
-    }
-    sort(ctx, entity, sort, { prefix }) {
-        const sortMap = buildSortMap(sort);
-        if (!hasKeys(sortMap)) {
-            return;
-        }
-        const meta = getMeta(entity);
-        // Separate vector search entries from direction entries before flattening,
-        // because flatObject recursively destructures objects — it would break QueryVectorSearch.
-        const vectorEntries = [];
-        const directionEntries = {};
-        for (const [key, val] of Object.entries(sortMap)) {
-            if (isVectorSearch(val)) {
-                vectorEntries.push([key, val]);
-            }
-            else {
-                directionEntries[key] = val;
-            }
-        }
-        const flattenedSort = flatObject(directionEntries, prefix);
-        // Merge: vector entries first (primary ordering), then flattened direction entries.
-        const allEntries = [...vectorEntries, ...Object.entries(flattenedSort)];
-        if (!allEntries.length)
-            return;
-        ctx.append(' ORDER BY ');
-        allEntries.forEach(([key, sort], index) => {
-            if (index > 0) {
-                ctx.append(', ');
-            }
-            if (isVectorSearch(sort)) {
-                if (sort.$project) {
-                    // Distance already projected in SELECT — reference the alias to avoid recomputation
-                    ctx.append(this.escapeId(sort.$project));
-                }
-                else {
-                    this.appendVectorSort(ctx, meta, key, sort);
-                }
-                return;
-            }
-            const direction = AbstractSqlDialect.SORT_DIRECTION_MAP[sort];
-            // Detect JSONB dot-notation: 'column.path'
-            const jsonDot = this.resolveJsonDotPath(meta, key);
-            if (jsonDot) {
-                ctx.append(jsonDot.accessor() + direction);
-                return;
-            }
-            const field = meta.fields[key];
-            const name = this.resolveColumnName(key, field);
-            ctx.append(this.escapeId(name) + direction);
-        });
-    }
-    /**
-     * Resolve common parameters for a vector similarity ORDER BY expression.
-     * Shared by all dialect overrides of `appendVectorSort`.
-     */
-    resolveVectorSortParams(meta, key, search) {
-        const field = meta.fields[key];
-        const colName = this.resolveColumnName(key, field);
-        const distance = search.$distance ?? field?.distance ?? 'cosine';
-        const vectorCast = resolveVectorCast(field);
-        return { colName, distance, field, vectorCast };
-    }
-    /**
-     * Mapping of UQL vector distance metrics to native SQL functions.
-     * Override in dialects that use function-call syntax (e.g. SQLite, MariaDB).
-     * Dialects with operator-based syntax (e.g. Postgres) leave this empty and override `appendVectorSort` directly.
-     */
-    vectorDistanceFns = {};
-    /**
-     * Append a vector similarity function call: `fn(col, ?)`.
-     * Used by dialects that express vector distance via SQL functions (SQLite, MariaDB).
-     */
-    appendFunctionVectorSort(ctx, meta, key, search, dialectName) {
-        const { colName, distance, vectorCast } = this.resolveVectorSortParams(meta, key, search);
-        const fn = this.vectorDistanceFns[distance];
-        if (!fn) {
-            throw Error(`${dialectName} does not support vector distance metric: ${distance}`);
-        }
-        ctx.append(`${fn}(${this.escapeId(colName)}, `);
-        ctx.addValue(`[${search.$vector.join(',')}]`);
-        if (vectorCast && dialectName === 'PostgreSQL') {
-            ctx.append(`::${vectorCast}`);
-        }
-        ctx.append(')');
-    }
-    /**
-     * Append a vector distance projection.
-     */
-    appendVectorProjection(ctx, meta, key, search) {
-        this.appendVectorSort(ctx, meta, key, search);
-        ctx.append(` AS ${this.escapeId(search.$project)}`);
-    }
-    /**
-     * Append a vector similarity ORDER BY expression.
-     * Default: auto-delegates to `appendFunctionVectorSort` when `vectorDistanceFns` has entries.
-     * Override for operator-based syntax (e.g. PostgreSQL `<=>`, `<->` operators).
-     */
-    appendVectorSort(ctx, meta, key, search) {
-        if (hasKeys(this.vectorDistanceFns)) {
-            this.appendFunctionVectorSort(ctx, meta, key, search, this.dialectName);
-            return;
-        }
-        throw new TypeError('Vector similarity sort is not supported by this dialect. Use raw() for vector queries.');
-    }
-    pager(ctx, opts) {
-        if (opts.$limit) {
-            ctx.append(` LIMIT ${Number(opts.$limit)}`);
-        }
-        if (opts.$skip !== undefined) {
-            ctx.append(` OFFSET ${Number(opts.$skip)}`);
-        }
-    }
-    count(ctx, entity, q, opts) {
-        const search = { ...q };
-        delete search.$sort;
-        this.select(ctx, entity, [raw('COUNT(*)', 'count')]);
-        this.search(ctx, entity, search, opts);
-    }
-    aggregate(ctx, entity, q, opts = {}) {
-        const meta = getMeta(entity);
-        const tableName = this.resolveTableName(entity, meta);
-        const groupKeys = [];
-        const selectParts = [];
-        const aggregateExpressions = {};
-        for (const entry of parseGroupMap(q.$group)) {
-            if (entry.kind === 'key') {
-                const field = meta.fields[entry.alias];
-                const columnName = this.resolveColumnName(entry.alias, field);
-                const escaped = this.escapeId(columnName);
-                groupKeys.push(escaped);
-                selectParts.push(columnName !== entry.alias ? `${escaped} ${this.escapeId(entry.alias)}` : escaped);
-            }
-            else {
-                const sqlFn = entry.op.slice(1).toUpperCase();
-                const sqlArg = entry.fieldRef === '*'
-                    ? '*'
-                    : this.escapeId(this.resolveColumnName(entry.fieldRef, meta.fields[entry.fieldRef]));
-                const expr = `${sqlFn}(${sqlArg})`;
-                aggregateExpressions[entry.alias] = expr;
-                selectParts.push(`${expr} ${this.escapeId(entry.alias)}`);
-            }
-        }
-        ctx.append(`SELECT ${selectParts.join(', ')} FROM ${this.escapeId(tableName)}`);
-        this.where(ctx, entity, q.$where, opts);
-        if (groupKeys.length) {
-            ctx.append(` GROUP BY ${groupKeys.join(', ')}`);
-        }
-        if (q.$having) {
-            this.having(ctx, q.$having, aggregateExpressions);
-        }
-        this.aggregateSort(ctx, q.$sort, aggregateExpressions);
-        this.pager(ctx, q);
-    }
-    /**
-     * ORDER BY for aggregate queries — handles both entity-field and alias references.
-     */
-    aggregateSort(ctx, sort, aggregateExpressions) {
-        const sortMap = buildSortMap(sort);
-        if (!hasKeys(sortMap))
-            return;
-        ctx.append(' ORDER BY ');
-        Object.entries(sortMap).forEach(([key, dir], index) => {
-            if (index > 0)
-                ctx.append(', ');
-            const direction = AbstractSqlDialect.SORT_DIRECTION_MAP[dir];
-            const ref = aggregateExpressions[key] ?? this.escapeId(key);
-            ctx.append(ref + direction);
-        });
-    }
-    having(ctx, having, aggregateExpressions) {
-        const entries = Object.entries(having).filter(([, v]) => v !== undefined);
-        if (!entries.length)
-            return;
-        ctx.append(' HAVING ');
-        entries.forEach(([alias, condition], index) => {
-            if (index > 0)
-                ctx.append(' AND ');
-            const expr = aggregateExpressions[alias] ?? this.escapeId(alias);
-            this.havingCondition(ctx, expr, condition);
-        });
-    }
-    static SORT_DIRECTION_MAP = Object.assign({ 1: '', asc: '', desc: ' DESC', '-1': ' DESC' }, { [-1]: ' DESC' });
-    static havingOpMap = {
-        $eq: '=',
-        $ne: '<>',
-        $gt: '>',
-        $gte: '>=',
-        $lt: '<',
-        $lte: '<=',
-    };
-    havingCondition(ctx, expr, condition) {
-        if (typeof condition !== 'object' || condition === null) {
-            ctx.append(`${expr} = `);
-            ctx.addValue(condition);
-            return;
-        }
-        const ops = condition;
-        const keys = getKeys(ops);
-        keys.forEach((op, i) => {
-            if (i > 0)
-                ctx.append(' AND ');
-            const val = ops[op];
-            if (op === '$between') {
-                const [min, max] = val;
-                ctx.append(`${expr} BETWEEN `);
-                ctx.addValue(min);
-                ctx.append(' AND ');
-                ctx.addValue(max);
-            }
-            else if (op === '$in' || op === '$nin') {
-                ctx.append(`${expr}${this.formatIn(ctx, Array.isArray(val) ? val : [], op === '$nin')}`);
-            }
-            else if (op === '$isNull') {
-                ctx.append(`${expr}${val ? ' IS NULL' : ' IS NOT NULL'}`);
-            }
-            else if (op === '$isNotNull') {
-                ctx.append(`${expr}${val ? ' IS NOT NULL' : ' IS NULL'}`);
-            }
-            else if (op === '$ne') {
-                ctx.append(this.neExpr(expr, this.addValue(ctx.values, val)));
-            }
-            else {
-                const sqlOp = AbstractSqlDialect.havingOpMap[op];
-                if (!sqlOp)
-                    throw TypeError(`unsupported HAVING operator: ${op}`);
-                ctx.append(`${expr} ${sqlOp} `);
-                ctx.addValue(val);
-            }
-        });
-    }
-    find(ctx, entity, q = {}, opts) {
-        this.select(ctx, entity, q.$select, q.$exclude, q.$populate, opts, q.$distinct, q.$sort);
-        this.search(ctx, entity, q, opts);
-    }
-    insert(ctx, entity, payload, opts) {
-        const meta = getMeta(entity);
-        const payloads = fillOnFields(meta, payload, 'onInsert');
-        const keys = filterFieldKeys(meta, payloads[0], 'onInsert');
-        const columns = keys.map((key) => {
-            const field = meta.fields[key];
-            return this.escapeId(this.resolveColumnName(key, field));
-        });
-        const tableName = this.resolveTableName(entity, meta);
-        ctx.append(`INSERT INTO ${this.escapeId(tableName)} (${columns.join(', ')}) VALUES (`);
-        payloads.forEach((it, recordIndex) => {
-            if (recordIndex > 0) {
-                ctx.append('), (');
-            }
-            keys.forEach((key, keyIndex) => {
-                if (keyIndex > 0) {
-                    ctx.append(', ');
-                }
-                const field = meta.fields[key];
-                this.formatPersistableValue(ctx, field, it[key]);
-            });
-        });
-        ctx.append(')');
-    }
-    update(ctx, entity, q, payload, opts) {
-        const meta = getMeta(entity);
-        const [filledPayload] = fillOnFields(meta, payload, 'onUpdate');
-        const keys = filterFieldKeys(meta, filledPayload, 'onUpdate');
-        const tableName = this.resolveTableName(entity, meta);
-        ctx.append(`UPDATE ${this.escapeId(tableName)} SET `);
-        keys.forEach((key, index) => {
-            if (index > 0) {
-                ctx.append(', ');
-            }
-            const field = meta.fields[key];
-            const columnName = this.resolveColumnName(key, field);
-            const escapedCol = this.escapeId(columnName);
-            const value = filledPayload[key];
-            if (this.isJsonUpdateOp(value)) {
-                this.formatJsonUpdate(ctx, escapedCol, value);
-            }
-            else {
-                ctx.append(`${escapedCol} = `);
-                this.formatPersistableValue(ctx, field, value);
-            }
-        });
-        this.search(ctx, entity, q, opts);
-    }
-    upsert(ctx, entity, conflictPaths, payload) {
-        const meta = getMeta(entity);
-        const updateCtx = this.createContext();
-        const update = this.getUpsertUpdateAssignments(updateCtx, meta, conflictPaths, payload, (name) => `VALUES(${name})`);
-        if (update) {
-            this.insert(ctx, entity, payload);
-            ctx.append(` ON DUPLICATE KEY UPDATE ${update}`);
-            ctx.pushValue(...updateCtx.values);
-        }
-        else {
-            const insertCtx = this.createContext();
-            this.insert(insertCtx, entity, payload);
-            ctx.append(insertCtx.sql.replace(/^INSERT/, 'INSERT IGNORE'));
-            ctx.pushValue(...insertCtx.values);
-        }
-    }
-    getUpsertUpdateAssignments(ctx, meta, conflictPaths, payload, callback) {
-        const sample = Array.isArray(payload) ? payload[0] : payload;
-        const cloned = { ...sample };
-        const [filledPayload] = fillOnFields(meta, cloned, 'onUpdate');
-        const fields = filterFieldKeys(meta, filledPayload, 'onUpdate');
-        return fields
-            .filter((col) => !conflictPaths[col])
-            .map((col) => {
-            const field = meta.fields[col];
-            const columnName = this.resolveColumnName(col, field);
-            if (callback && Object.hasOwn(sample, col)) {
-                return `${this.escapeId(columnName)} = ${callback(this.escapeId(columnName))}`;
-            }
-            const valCtx = this.createContext();
-            this.formatPersistableValue(valCtx, field, filledPayload[col]);
-            ctx.pushValue(...valCtx.values);
-            return `${this.escapeId(columnName)} = ${valCtx.sql}`;
-        })
-            .join(', ');
-    }
-    /**
-     * Shared ON CONFLICT ... DO UPDATE / DO NOTHING logic for positional-placeholder dialects (SQLite).
-     * Uses a deferred context for update params so they follow INSERT params.
-     * PG uses its own implementation since `$N` numbered placeholders handle param ordering natively.
-     */
-    onConflictUpsert(ctx, entity, conflictPaths, payload, insertFn) {
-        const meta = getMeta(entity);
-        const updateCtx = this.createContext();
-        const update = this.getUpsertUpdateAssignments(updateCtx, meta, conflictPaths, payload, (name) => `EXCLUDED.${name}`);
-        const keysStr = this.getUpsertConflictPathsStr(meta, conflictPaths);
-        const onConflict = update ? `DO UPDATE SET ${update}` : 'DO NOTHING';
-        insertFn(ctx, entity, payload);
-        ctx.append(` ON CONFLICT (${keysStr}) ${onConflict}`);
-        ctx.pushValue(...updateCtx.values);
-    }
-    getUpsertConflictPathsStr(meta, conflictPaths) {
-        return getKeys(conflictPaths)
-            .map((key) => {
-            const field = meta.fields[key];
-            const columnName = this.resolveColumnName(key, field);
-            return this.escapeId(columnName);
-        })
-            .join(', ');
-    }
-    delete(ctx, entity, q, opts = {}) {
-        const meta = getMeta(entity);
-        const tableName = this.resolveTableName(entity, meta);
-        if (opts.softDelete || opts.softDelete === undefined) {
-            if (meta.softDelete) {
-                const field = meta.fields[meta.softDelete];
-                if (!field?.onDelete)
-                    return;
-                const value = getFieldCallbackValue(field.onDelete);
-                const columnName = this.resolveColumnName(meta.softDelete, field);
-                ctx.append(`UPDATE ${this.escapeId(tableName)} SET ${this.escapeId(columnName)} = `);
-                ctx.addValue(value);
-                this.search(ctx, entity, q, opts);
-                return;
-            }
-            if (opts.softDelete) {
-                throw TypeError(`'${tableName}' has not enabled 'softDelete'`);
-            }
-        }
-        ctx.append(`DELETE FROM ${this.escapeId(tableName)}`);
-        this.search(ctx, entity, q, opts);
-    }
-    escapeId(val, forbidQualified, addDot) {
-        return escapeSqlId(val, this.escapeIdChar, forbidQualified, addDot);
-    }
-    getPersistables(ctx, meta, payload, callbackKey) {
-        const payloads = fillOnFields(meta, payload, callbackKey);
-        return payloads.map((it) => this.getPersistable(ctx, meta, it, callbackKey));
-    }
-    getPersistable(ctx, meta, payload, callbackKey) {
-        const filledPayload = fillOnFields(meta, payload, callbackKey)[0];
-        const keys = filterFieldKeys(meta, filledPayload, callbackKey);
-        return keys.reduce((acc, key) => {
-            const field = meta.fields[key];
-            const valCtx = this.createContext();
-            this.formatPersistableValue(valCtx, field, filledPayload[key]);
-            ctx.pushValue(...valCtx.values);
-            acc[key] = valCtx.sql;
-            return acc;
-        }, {});
-    }
-    formatPersistableValue(ctx, field, value) {
-        if (value instanceof QueryRaw) {
-            this.getRawValue(ctx, { value });
-            return;
-        }
-        if (isJsonType(field?.type)) {
-            ctx.addValue(value == null ? null : JSON.stringify(value));
-            return;
-        }
-        if (field?.type === 'vector' && Array.isArray(value)) {
-            ctx.addValue(`[${value.join(',')}]`);
-            return;
-        }
-        ctx.addValue(value);
-    }
-    /**
-     * Generate SQL for a JSONB merge and/or unset operation.
-     * Called from `update()` when a field value has `$merge`, `$unset`, and/or `$push` operators.
-     * Generates the full `"col" = <expression>` assignment.
-     *
-     * Base implementation uses MySQL-compatible syntax with *shallow* merge semantics
-     * (RHS top-level keys replace LHS top-level keys, matching PostgreSQL's `jsonb || jsonb`).
-     * Override in dialect subclasses when a dialect needs different JSON function semantics.
-     */
-    getJsonCastExpr() {
-        return 'CAST(? AS JSON)';
-    }
-    formatJsonUpdate(ctx, escapedCol, value) {
-        let expr = escapedCol;
-        if (hasKeys(value.$merge)) {
-            const merge = value.$merge;
-            expr = `JSON_SET(COALESCE(${escapedCol}, '{}')`;
-            for (const [key, v] of Object.entries(merge)) {
-                expr += `, '$.${this.escapeJsonKey(key)}', ${this.getJsonCastExpr()}`;
-                ctx.pushValue(JSON.stringify(v));
-            }
-            expr += ')';
-        }
-        if (hasKeys(value.$push)) {
-            const push = value.$push;
-            expr = `JSON_ARRAY_APPEND(${expr}`;
-            for (const [key, v] of Object.entries(push)) {
-                expr += `, '$.${this.escapeJsonKey(key)}', ${this.getJsonCastExpr()}`;
-                ctx.pushValue(JSON.stringify(v));
-            }
-            expr += ')';
-        }
-        if (value.$unset?.length) {
-            for (const key of value.$unset) {
-                expr = `JSON_REMOVE(${expr}, '$.${this.escapeJsonKey(key)}')`;
-            }
-        }
-        ctx.append(`${escapedCol} = ${expr}`);
-    }
-    isJsonUpdateOp(value) {
-        return typeof value === 'object' && value !== null && ('$merge' in value || '$unset' in value || '$push' in value);
-    }
-    /** Escapes a JSON key for safe interpolation into SQL string literals. */
-    escapeJsonKey(key) {
-        return key.replace(/'/g, "''");
-    }
-    getRawValue(ctx, opts) {
-        const { value, prefix = '', escapedPrefix, autoPrefixAlias } = opts;
-        const rawValue = value[RAW_VALUE];
-        if (typeof rawValue === 'function') {
-            const res = rawValue({
-                ...opts,
-                ctx,
-                dialect: this,
-                prefix,
-                escapedPrefix: escapedPrefix ?? this.escapeId(prefix, true, true),
-            });
-            if (typeof res === 'string' || (typeof res === 'number' && !Number.isNaN(res))) {
-                ctx.append(String(res));
-            }
-        }
-        else {
-            ctx.append(prefix + String(rawValue));
-        }
-        const alias = value[RAW_ALIAS];
-        if (alias) {
-            const fullAlias = autoPrefixAlias && prefix ? `${prefix}.${alias}` : alias;
-            ctx.append(' ' + this.escapeId(fullAlias, true));
-        }
-    }
-    /**
-     * Resolves a dot-notation key to its JSON field metadata.
-     * Shared by `where()` and `sort()` to detect 'column.path' keys where 'column' is a JSON/JSONB field.
-     *
-     * @returns resolved metadata or `undefined` if the key is not a JSON dot-notation path
-     */
-    resolveJsonDotPath(meta, key, prefix) {
-        const dotIndex = key.indexOf('.');
-        if (dotIndex <= 0) {
-            return undefined;
-        }
-        const root = key.slice(0, dotIndex);
-        const field = meta.fields[root];
-        if (!field || !isJsonType(field.type)) {
-            return undefined;
-        }
-        const jsonPath = key.slice(dotIndex + 1);
-        const colName = this.resolveColumnName(root, field);
-        const escapedCol = (prefix ? this.escapeId(prefix, true, true) : '') + this.escapeId(colName);
-        return {
-            root,
-            jsonPath,
-            accessor: (asJsonb) => asJsonb ? this.getJsonPathJsonbExpr(escapedCol, jsonPath) : this.getJsonPathScalarExpr(escapedCol, jsonPath),
-        };
-    }
-    /**
-     * Compare a JSONB dot-notation path, e.g. `'settings.isArchived': { $ne: true }`.
-     * Receives a pre-resolved `resolveJsonDotPath` result to avoid redundant computation.
-     */
-    compareJsonPath(ctx, resolved, val) {
-        const { jsonPath, accessor } = resolved;
-        const value = this.normalizeWhereValue(val);
-        const operators = getKeys(value);
-        if (operators.length > 1) {
-            ctx.append('(');
-        }
-        operators.forEach((op, index) => {
-            if (index > 0)
-                ctx.append(' AND ');
-            const sql = this.buildJsonFieldCondition(ctx, (f) => accessor(this.isJsonbOp(op)), jsonPath, op, value[op]);
-            if (sql) {
-                ctx.append(sql);
-            }
-        });
-        if (operators.length > 1) {
-            ctx.append(')');
-        }
-    }
-    /**
-     * Returns SQL that extracts a scalar value from a JSON path.
-     * Dialects can override this to customize path access syntax while preserving
-     * the shared comparison/operator pipeline.
-     */
-    getJsonPathScalarExpr(escapedColumn, jsonPath) {
-        const segments = jsonPath.split('.');
-        let expr = escapedColumn;
-        for (let i = 0; i < segments.length; i++) {
-            const op = i === segments.length - 1 ? '->>' : '->';
-            expr = `(${expr}${op}'${this.escapeJsonKey(segments[i])}')`;
-        }
-        return expr;
-    }
-    getJsonPathJsonbExpr(escapedColumn, jsonPath) {
-        const segments = jsonPath.split('.');
-        let expr = escapedColumn;
-        for (const segment of segments) {
-            expr = `(${expr}->'${this.escapeJsonKey(segment)}')`;
-        }
-        return expr;
-    }
-    /**
-     * Normalizes a raw WHERE value into an operator map.
-     * Arrays become `$in`, scalars/null become `$eq`, objects pass through.
-     */
-    normalizeWhereValue(val) {
-        if (Array.isArray(val))
-            return { $in: val };
-        if (typeof val === 'object' && val !== null)
-            return val;
-        return { $eq: val };
-    }
-    /**
-     * Filter by relation using an EXISTS subquery.
-     * Supports all cardinalities: mm (via junction), 1m, m1, and 11.
-     */
-    compareRelation(ctx, entity, key, val, rel, opts) {
-        const meta = getMeta(entity);
-        const parentTable = this.resolveTableName(entity, meta);
-        const parentId = meta.id;
-        const escapedParentId = (opts.prefix ? this.escapeId(opts.prefix, true, true) : this.escapeId(parentTable, false, true)) +
-            this.escapeId(parentId);
-        if (!rel.references?.length) {
-            throw new TypeError(`Relation '${key}' on '${parentTable}' has no references defined`);
-        }
-        const relatedEntity = rel.entity();
-        const relatedMeta = getMeta(relatedEntity);
-        const relatedTable = this.resolveTableName(relatedEntity, relatedMeta);
-        ctx.append('EXISTS (SELECT 1 FROM ');
-        if (rel.cardinality === 'mm' && rel.through) {
-            // ManyToMany: EXISTS (SELECT 1 FROM JunctionTable WHERE junction.localFk = parent.id AND junction.foreignFk IN (SELECT related.id FROM Related WHERE ...))
-            const throughEntity = rel.through();
-            const throughMeta = getMeta(throughEntity);
-            const throughTable = this.resolveTableName(throughEntity, throughMeta);
-            const localFk = rel.references[0].local;
-            const foreignFk = rel.references[1].local;
-            const relatedId = relatedMeta.id;
-            ctx.append(this.escapeId(throughTable));
-            ctx.append(` WHERE ${this.escapeId(throughTable, false, true)}${this.escapeId(localFk)} = ${escapedParentId}`);
-            ctx.append(` AND ${this.escapeId(throughTable, false, true)}${this.escapeId(foreignFk)} IN (`);
-            ctx.append(`SELECT ${this.escapeId(relatedTable, false, true)}${this.escapeId(relatedId)} FROM ${this.escapeId(relatedTable)}`);
-            this.where(ctx, relatedEntity, val, {
-                prefix: relatedTable,
-                clause: 'WHERE',
-                softDelete: false,
-            });
-            ctx.append(')');
-        }
-        else {
-            // 1m / m1 / 11: EXISTS (SELECT 1 FROM Related WHERE related.fk_or_pk = parent.pk_or_fk AND ...)
-            // Left side is always relatedTable.references[0].foreign
-            // Right side is the parent's PK (1m) or the parent's FK (m1/11)
-            const joinLeft = `${this.escapeId(relatedTable, false, true)}${this.escapeId(rel.references[0].foreign)}`;
-            const joinRight = rel.cardinality === '1m'
-                ? escapedParentId
-                : (opts.prefix ? this.escapeId(opts.prefix, true, true) : this.escapeId(parentTable, false, true)) +
-                    this.escapeId(rel.references[0].local);
-            ctx.append(this.escapeId(relatedTable));
-            ctx.append(` WHERE ${joinLeft} = ${joinRight}`);
-            this.where(ctx, relatedEntity, val, {
-                prefix: relatedTable,
-                clause: 'AND',
-                softDelete: false,
-            });
-        }
-        ctx.append(')');
-    }
-    /**
-     * Filter by relation size using a `COUNT(*)` subquery.
-     * Supports all cardinalities: mm (via junction), 1m.
-     */
-    compareRelationSize(ctx, entity, key, sizeVal, rel, opts) {
-        const meta = getMeta(entity);
-        const parentTable = this.resolveTableName(entity, meta);
-        const parentId = meta.id;
-        const escapedParentId = (opts.prefix ? this.escapeId(opts.prefix, true, true) : this.escapeId(parentTable, false, true)) +
-            this.escapeId(parentId);
-        if (!rel.references?.length) {
-            throw new TypeError(`Relation '${key}' on '${parentTable}' has no references defined`);
-        }
-        const appendSubquery = () => {
-            ctx.append('(SELECT COUNT(*) FROM ');
-            if (rel.cardinality === 'mm' && rel.through) {
-                const throughEntity = rel.through();
-                const throughMeta = getMeta(throughEntity);
-                const throughTable = this.resolveTableName(throughEntity, throughMeta);
-                const localFk = rel.references[0].local;
-                ctx.append(this.escapeId(throughTable));
-                ctx.append(` WHERE ${this.escapeId(throughTable, false, true)}${this.escapeId(localFk)} = ${escapedParentId}`);
-            }
-            else {
-                const relatedEntity = rel.entity();
-                const relatedMeta = getMeta(relatedEntity);
-                const relatedTable = this.resolveTableName(relatedEntity, relatedMeta);
-                const joinLeft = `${this.escapeId(relatedTable, false, true)}${this.escapeId(rel.references[0].foreign)}`;
-                ctx.append(this.escapeId(relatedTable));
-                ctx.append(` WHERE ${joinLeft} = ${escapedParentId}`);
-            }
-            ctx.append(')');
-        };
-        this.buildSizeComparison(ctx, appendSubquery, sizeVal);
-    }
-    /**
-     * Build a complete `$size` comparison expression.
-     * Handles both single and multiple comparison operators by repeating the size expression.
-     * @param sizeExprFn - function that appends the size expression to ctx (e.g. `jsonb_array_length("col")`)
-     */
-    buildSizeComparison(ctx, sizeExprFn, sizeVal) {
-        if (typeof sizeVal === 'number') {
-            sizeExprFn();
-            ctx.append(' = ');
-            ctx.addValue(sizeVal);
-            return;
-        }
-        const entries = Object.entries(sizeVal).filter(([, v]) => v !== undefined);
-        if (entries.length > 1) {
-            ctx.append('(');
-        }
-        entries.forEach(([op, val], index) => {
-            if (index > 0) {
-                ctx.append(' AND ');
-            }
-            sizeExprFn();
-            this.appendSizeOp(ctx, op, val);
-        });
-        if (entries.length > 1) {
-            ctx.append(')');
-        }
-    }
-    /**
-     * Append a single size comparison operator and value to the context.
-     */
-    appendSizeOp(ctx, op, val) {
-        switch (op) {
-            case '$eq':
-                ctx.append(' = ');
-                ctx.addValue(val);
-                break;
-            case '$ne':
-                ctx.append(' <> ');
-                ctx.addValue(val);
-                break;
-            case '$gt':
-                ctx.append(' > ');
-                ctx.addValue(val);
-                break;
-            case '$gte':
-                ctx.append(' >= ');
-                ctx.addValue(val);
-                break;
-            case '$lt':
-                ctx.append(' < ');
-                ctx.addValue(val);
-                break;
-            case '$lte':
-                ctx.append(' <= ');
-                ctx.addValue(val);
-                break;
-            case '$between': {
-                const [min, max] = val;
-                ctx.append(' BETWEEN ');
-                ctx.addValue(min);
-                ctx.append(' AND ');
-                ctx.addValue(max);
-                break;
-            }
-            default:
-                throw TypeError(`unsupported $size comparison operator: ${op}`);
-        }
-    }
-    get regexpOp() {
-        return 'REGEXP';
-    }
-    get likeFn() {
-        return 'LIKE';
-    }
-    /**
-     * Not-equal operator token for non-null comparisons.
-     * Postgres uses `IS DISTINCT FROM`; MySQL/Maria uses custom `neExpr`.
-     */
-    get neOp() {
-        return '<>';
-    }
-    neExpr(field, ph) {
-        return `${field} ${this.neOp} ${ph}`;
-    }
-    ilikeExpr(f, ph) {
-        return `LOWER(${f}) LIKE ${ph}`;
-    }
-    /**
-     * Formats an IN/NOT IN expression, binding each value individually.
-     * Postgres overrides to use `= ANY($1)` / `<> ALL($1)` with a single array parameter.
-     */
-    formatIn(ctx, values, negate) {
-        if (values.length === 0)
-            return negate ? ' NOT IN (NULL)' : ' IN (NULL)';
-        const phs = values.map((v) => this.addValue(ctx.values, v)).join(', ');
-        return ` ${negate ? 'NOT IN' : 'IN'} (${phs})`;
-    }
-    numericCast(expr) {
-        return expr;
-    }
-    toString() {
-        return this.dialectName;
-    }
-}
-//# sourceMappingURL=abstractSqlDialect.js.map