@uql/core 1.0.12 → 3.1.0

package/src/dialect/abstractSqlDialect.ts

@@ -0,0 +1,805 @@
+import { getMeta } from '../entity/index.js';
+import {
+  type EntityMeta,
+  type FieldKey,
+  type FieldOptions,
+  type NamingStrategy,
+  type Query,
+  type QueryComparisonOptions,
+  type QueryConflictPaths,
+  type QueryContext,
+  type QueryDialect,
+  type QueryOptions,
+  type QueryPager,
+  QueryRaw,
+  type QueryRawFnOptions,
+  type QuerySearch,
+  type QuerySelect,
+  type QuerySelectArray,
+  type QuerySelectOptions,
+  type QuerySort,
+  type QuerySortDirection,
+  type QueryTextSearchOptions,
+  type QueryWhere,
+  type QueryWhereArray,
+  type QueryWhereFieldOperatorMap,
+  type QueryWhereMap,
+  type QueryWhereOptions,
+  type SqlQueryDialect,
+  type Type,
+} from '../type/index.js';
+
+import {
+  buildSortMap,
+  buldQueryWhereAsMap,
+  type CallbackKey,
+  escapeSqlId,
+  fillOnFields,
+  filterFieldKeys,
+  filterRelationKeys,
+  flatObject,
+  getFieldCallbackValue,
+  getFieldKeys,
+  getKeys,
+  hasKeys,
+  isSelectingRelations,
+  raw,
+} from '../util/index.js';
+
+import { AbstractDialect } from './abstractDialect.js';
+import { SqlQueryContext } from './queryContext.js';
+
+export abstract class AbstractSqlDialect extends AbstractDialect implements QueryDialect, SqlQueryDialect {
+  constructor(
+    namingStrategy?: NamingStrategy,
+    readonly escapeIdChar: '`' | '"' = '`',
+    readonly beginTransactionCommand: string = 'START TRANSACTION',
+    readonly commitTransactionCommand: string = 'COMMIT',
+    readonly rollbackTransactionCommand: string = 'ROLLBACK',
+  ) {
+    super(namingStrategy);
+  }
+
+  createContext(): QueryContext {
+    return new SqlQueryContext(this);
+  }
+
+  addValue(values: unknown[], value: unknown): string {
+    values.push(value ?? null);
+    return this.placeholder(values.length);
+  }
+
+  placeholder(_index: number): string {
+    return '?';
+  }
+
+  returningId<E>(entity: Type<E>): string {
+    const meta = getMeta(entity);
+    const idName = this.resolveColumnName(meta.id, meta.fields[meta.id]);
+    return `RETURNING ${this.escapeId(idName)} ${this.escapeId('id')}`;
+  }
+
+  search<E>(ctx: QueryContext, entity: Type<E>, q: Query<E> = {}, opts: QueryOptions = {}): void {
+    const meta = getMeta(entity);
+    const tableName = this.resolveTableName(entity, meta);
+    const prefix = (opts.prefix ?? (opts.autoPrefix || isSelectingRelations(meta, q.$select))) ? tableName : undefined;
+    opts = { ...opts, prefix };
+    this.where<E>(ctx, entity, q.$where, opts);
+    this.sort<E>(ctx, entity, q.$sort, opts);
+    this.pager(ctx, q);
+  }
+
+  selectFields<E>(ctx: QueryContext, entity: Type<E>, select: QuerySelect<E>, opts: QuerySelectOptions = {}): void {
+    const meta = getMeta(entity);
+    const prefix = opts.prefix ? opts.prefix + '.' : '';
+    const escapedPrefix = this.escapeId(opts.prefix, true, true);
+
+    let selectArr: QuerySelectArray<E>;
+
+    if (select) {
+      if (Array.isArray(select)) {
+        selectArr = select;
+      } else {
+        const selectPositive = getKeys(select).filter((it) => select[it]) as FieldKey<E>[];
+        selectArr = selectPositive.length
+          ? selectPositive
+          : (getFieldKeys(meta.fields).filter((it) => !(it in select)) as FieldKey<E>[]);
+      }
+      selectArr = selectArr.filter((it) => it instanceof QueryRaw || it in meta.fields);
+      if (opts.prefix && !selectArr.includes(meta.id)) {
+        selectArr = [meta.id, ...selectArr];
+      }
+    } else {
+      selectArr = getFieldKeys(meta.fields) as FieldKey<E>[];
+    }
+
+    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 as FieldKey<E>];
+        const columnName = this.resolveColumnName(key, field);
+        if (field.virtual) {
+          this.getRawValue(ctx, {
+            value: raw(field.virtual.value, key as string),
+            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) as string;
+          // Replace dots with underscores for alias to avoid syntax errors
+          const safeAlias = aliasStr.replace(/\./g, '_');
+          ctx.append(' ' + this.escapeId(safeAlias, true));
+        }
+      }
+    });
+  }
+
+  select<E>(ctx: QueryContext, entity: Type<E>, select: QuerySelect<E>, opts: QueryOptions = {}): void {
+    const meta = getMeta(entity);
+    const tableName = this.resolveTableName(entity, meta);
+    const prefix = (opts.prefix ?? (opts.autoPrefix || isSelectingRelations(meta, select))) ? tableName : undefined;
+
+    ctx.append('SELECT ');
+    this.selectFields(ctx, entity, select, { prefix });
+    // Add related fields BEFORE FROM clause
+    this.selectRelationFields(ctx, entity, select, { prefix });
+    ctx.append(` FROM ${this.escapeId(tableName)}`);
+    // Add JOINs AFTER FROM clause
+    this.selectRelationJoins(ctx, entity, select, { prefix });
+  }
+
+  protected selectRelationFields<E>(
+    ctx: QueryContext,
+    entity: Type<E>,
+    select: QuerySelect<E>,
+    opts: { prefix?: string } = {},
+  ): void {
+    if (Array.isArray(select)) {
+      return;
+    }
+
+    const meta = getMeta(entity);
+    const tableName = this.resolveTableName(entity, meta);
+    const relKeys = filterRelationKeys(meta, select);
+    const isSelectArray = Array.isArray(select);
+    const prefix = opts.prefix;
+
+    for (const relKey of relKeys) {
+      const relOpts = meta.relations[relKey];
+
+      if (relOpts.cardinality === '1m' || relOpts.cardinality === 'mm') {
+        continue;
+      }
+
+      const isFirstLevel = prefix === tableName;
+      const joinRelAlias = isFirstLevel ? relKey : prefix ? prefix + '.' + relKey : relKey;
+      const relEntity = relOpts.entity();
+      const relSelect = select[relKey as string];
+      const relQuery = isSelectArray ? {} : Array.isArray(relSelect) ? { $select: relSelect } : relSelect;
+
+      ctx.append(', ');
+      this.selectFields(ctx, relEntity, relQuery.$select, {
+        prefix: joinRelAlias,
+        autoPrefixAlias: true,
+      });
+
+      // Recursively add nested relation fields
+      this.selectRelationFields(ctx, relEntity, relQuery.$select, {
+        prefix: joinRelAlias,
+      });
+    }
+  }
+
+  protected selectRelationJoins<E>(
+    ctx: QueryContext,
+    entity: Type<E>,
+    select: QuerySelect<E>,
+    opts: { prefix?: string } = {},
+  ): void {
+    if (Array.isArray(select)) {
+      return;
+    }
+
+    const meta = getMeta(entity);
+    const tableName = this.resolveTableName(entity, meta);
+    const relKeys = filterRelationKeys(meta, select);
+    const isSelectArray = Array.isArray(select);
+    const prefix = opts.prefix;
+
+    for (const relKey of relKeys) {
+      const relOpts = meta.relations[relKey];
+
+      if (relOpts.cardinality === '1m' || relOpts.cardinality === 'mm') {
+        continue;
+      }
+
+      const isFirstLevel = prefix === tableName;
+      const joinRelAlias = isFirstLevel ? (relKey as string) : prefix ? prefix + '.' + relKey : (relKey as string);
+      const relEntity = relOpts.entity();
+      const relSelect = select[relKey as string];
+      const relQuery = isSelectArray ? {} : Array.isArray(relSelect) ? { $select: relSelect } : relSelect;
+
+      const relMeta = getMeta(relEntity);
+      const relTableName = this.resolveTableName(relEntity, relMeta);
+      const relEntityName = this.escapeId(relTableName);
+      const relPath = prefix ? this.escapeId(prefix, true) : this.escapeId(tableName);
+      const joinType = relQuery.$required ? 'INNER' : 'LEFT';
+      const joinAlias = this.escapeId(joinRelAlias, true);
+
+      ctx.append(` ${joinType} JOIN ${relEntityName} ${joinAlias} ON `);
+      ctx.append(
+        relOpts.references
+          .map((it) => {
+            const foreignColumnName = this.resolveColumnName(it.foreign, relMeta.fields[it.foreign]);
+            const localColumnName = this.resolveColumnName(it.local, meta.fields[it.local]);
+            return `${joinAlias}.${this.escapeId(foreignColumnName)} = ${relPath}.${this.escapeId(localColumnName)}`;
+          })
+          .join(' AND '),
+      );
+
+      if (relQuery.$where) {
+        ctx.append(' AND ');
+        this.where(ctx, relEntity, relQuery.$where, { prefix: joinRelAlias, clause: false });
+      }
+
+      // Recursively add nested relation JOINs
+      this.selectRelationJoins(ctx, relEntity, relQuery.$select, {
+        prefix: joinRelAlias,
+      });
+    }
+  }
+
+  where<E>(ctx: QueryContext, entity: Type<E>, where: QueryWhere<E> = {}, opts: QueryWhereOptions = {}): void {
+    const meta = getMeta(entity);
+    const { usePrecedence, clause = 'WHERE', softDelete } = opts;
+
+    where = buldQueryWhereAsMap(meta, where);
+
+    if (meta.softDelete && (softDelete || softDelete === undefined) && !where[meta.softDelete as string]) {
+      where[meta.softDelete as string] = null;
+    }
+
+    const entries = Object.entries(where);
+
+    if (!entries.length) {
+      return;
+    }
+
+    if (clause) {
+      ctx.append(` ${clause} `);
+    }
+
+    if (usePrecedence) {
+      ctx.append('(');
+    }
+
+    entries.forEach(([key, val], index) => {
+      if (index > 0) {
+        ctx.append(' AND ');
+      }
+      this.compare(ctx, entity, key as keyof QueryWhereMap<E>, val as any, {
+        ...opts,
+        usePrecedence: entries.length > 1,
+      });
+    });
+
+    if (usePrecedence) {
+      ctx.append(')');
+    }
+  }
+
+  compare<E, K extends keyof QueryWhereMap<E>>(
+    ctx: QueryContext,
+    entity: Type<E>,
+    key: K,
+    val: QueryWhereMap<E>[K],
+    opts: QueryComparisonOptions = {},
+  ): void {
+    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 as FieldKey<E>, opts);
+      ctx.append(' = ');
+      this.getRawValue(ctx, { value: val });
+      return;
+    }
+
+    if (key === '$text') {
+      const search = val as QueryTextSearchOptions<E>;
+      const fields = search.$fields.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') {
+      const negateOperatorMap = {
+        $not: '$and',
+        $nor: '$or',
+      } as const;
+
+      const op: '$and' | '$or' = negateOperatorMap[key as string] ?? key;
+      const negate = key in negateOperatorMap ? 'NOT' : '';
+
+      const valArr = val as QueryWhereArray<E>;
+      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,
+            prefix: opts.prefix,
+            escapedPrefix: this.escapeId(opts.prefix, true, true),
+          });
+        } else {
+          this.where(ctx, entity, whereEntry, {
+            prefix: opts.prefix,
+            usePrecedence: hasManyItems && !Array.isArray(whereEntry) && getKeys(whereEntry).length > 1,
+            clause: false,
+          });
+        }
+      });
+
+      if ((opts.usePrecedence || negate) && hasManyItems) {
+        ctx.append(')');
+      }
+      return;
+    }
+
+    const value = Array.isArray(val) ? { $in: val } : typeof val === 'object' && val !== null ? val : { $eq: val };
+    const operators = getKeys(value) as (keyof QueryWhereFieldOperatorMap<E>)[];
+
+    if (operators.length > 1) {
+      ctx.append('(');
+    }
+
+    operators.forEach((op, index) => {
+      if (index > 0) {
+        ctx.append(' AND ');
+      }
+      this.compareFieldOperator(ctx, entity, key as FieldKey<E>, op, value[op], opts);
+    });
+
+    if (operators.length > 1) {
+      ctx.append(')');
+    }
+  }
+
+  compareFieldOperator<E, K extends keyof QueryWhereFieldOperatorMap<E>>(
+    ctx: QueryContext,
+    entity: Type<E>,
+    key: FieldKey<E>,
+    op: K,
+    val: QueryWhereFieldOperatorMap<E>[K],
+    opts: QueryOptions = {},
+  ): void {
+    switch (op) {
+      case '$eq':
+        this.getComparisonKey(ctx, entity, key, opts);
+        if (val === null) {
+          ctx.append(' IS NULL');
+        } else {
+          ctx.append(' = ');
+          ctx.addValue(val);
+        }
+        break;
+      case '$ne':
+        this.getComparisonKey(ctx, entity, key, opts);
+        if (val === null) {
+          ctx.append(' IS NOT NULL');
+        } else {
+          ctx.append(' <> ');
+          ctx.addValue(val);
+        }
+        break;
+      case '$not':
+        ctx.append('NOT (');
+        this.compare(ctx, entity, key as any, val as any, opts);
+        ctx.append(')');
+        break;
+      case '$gt':
+        this.getComparisonKey(ctx, entity, key, opts);
+        ctx.append(' > ');
+        ctx.addValue(val);
+        break;
+      case '$gte':
+        this.getComparisonKey(ctx, entity, key, opts);
+        ctx.append(' >= ');
+        ctx.addValue(val);
+        break;
+      case '$lt':
+        this.getComparisonKey(ctx, entity, key, opts);
+        ctx.append(' < ');
+        ctx.addValue(val);
+        break;
+      case '$lte':
+        this.getComparisonKey(ctx, entity, key, opts);
+        ctx.append(' <= ');
+        ctx.addValue(val);
+        break;
+      case '$startsWith':
+        this.getComparisonKey(ctx, entity, key, opts);
+        ctx.append(' LIKE ');
+        ctx.addValue(`${val}%`);
+        break;
+      case '$istartsWith':
+        this.getComparisonKey(ctx, entity, key, opts);
+        ctx.append(' LIKE ');
+        ctx.addValue(`${(val as string).toLowerCase()}%`);
+        break;
+      case '$endsWith':
+        this.getComparisonKey(ctx, entity, key, opts);
+        ctx.append(' LIKE ');
+        ctx.addValue(`%${val}`);
+        break;
+      case '$iendsWith':
+        this.getComparisonKey(ctx, entity, key, opts);
+        ctx.append(' LIKE ');
+        ctx.addValue(`%${(val as string).toLowerCase()}`);
+        break;
+      case '$includes':
+        this.getComparisonKey(ctx, entity, key, opts);
+        ctx.append(' LIKE ');
+        ctx.addValue(`%${val}%`);
+        break;
+      case '$iincludes':
+        this.getComparisonKey(ctx, entity, key, opts);
+        ctx.append(' LIKE ');
+        ctx.addValue(`%${(val as string).toLowerCase()}%`);
+        break;
+      case '$ilike':
+        this.getComparisonKey(ctx, entity, key, opts);
+        ctx.append(' LIKE ');
+        ctx.addValue((val as string).toLowerCase());
+        break;
+      case '$like':
+        this.getComparisonKey(ctx, entity, key, opts);
+        ctx.append(' LIKE ');
+        ctx.addValue(val);
+        break;
+      case '$in':
+        this.getComparisonKey(ctx, entity, key, opts);
+        if (Array.isArray(val) && val.length > 0) {
+          ctx.append(' IN (');
+          this.addValues(ctx, val as any[]);
+          ctx.append(')');
+        } else {
+          ctx.append(' IN (NULL)');
+        }
+        break;
+      case '$nin':
+        this.getComparisonKey(ctx, entity, key, opts);
+        if (Array.isArray(val) && val.length > 0) {
+          ctx.append(' NOT IN (');
+          this.addValues(ctx, val as any[]);
+          ctx.append(')');
+        } else {
+          ctx.append(' NOT IN (NULL)');
+        }
+        break;
+      case '$regex':
+        this.getComparisonKey(ctx, entity, key, opts);
+        ctx.append(' REGEXP ');
+        ctx.addValue(val);
+        break;
+      default:
+        throw TypeError(`unknown operator: ${op}`);
+    }
+  }
+
+  protected addValues(ctx: QueryContext, vals: unknown[]): void {
+    vals.forEach((val, index) => {
+      if (index > 0) {
+        ctx.append(', ');
+      }
+      ctx.addValue(val);
+    });
+  }
+
+  getComparisonKey<E>(ctx: QueryContext, entity: Type<E>, key: FieldKey<E>, { prefix }: QueryOptions = {}): void {
+    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<E>(ctx: QueryContext, entity: Type<E>, sort: QuerySort<E>, { prefix }: QueryOptions): void {
+    const sortMap = buildSortMap(sort);
+    if (!hasKeys(sortMap)) {
+      return;
+    }
+    const meta = getMeta(entity);
+    const flattenedSort = flatObject(sortMap, prefix);
+    const directionMap = { 1: '', asc: '', '-1': ' DESC', desc: ' DESC' } as const;
+
+    ctx.append(' ORDER BY ');
+
+    Object.entries(flattenedSort).forEach(([key, sort], index) => {
+      if (index > 0) {
+        ctx.append(', ');
+      }
+      const field = meta.fields[key];
+      const name = this.resolveColumnName(key, field);
+      const direction = directionMap[sort as QuerySortDirection];
+      ctx.append(this.escapeId(name) + direction);
+    });
+  }
+
+  pager(ctx: QueryContext, opts: QueryPager): void {
+    if (opts.$limit) {
+      ctx.append(` LIMIT ${Number(opts.$limit)}`);
+    }
+    if (opts.$skip !== undefined) {
+      ctx.append(` OFFSET ${Number(opts.$skip)}`);
+    }
+  }
+
+  count<E>(ctx: QueryContext, entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions): void {
+    const search: Query<E> = { ...q };
+    delete search.$sort;
+    this.select<E>(ctx, entity, [raw('COUNT(*)', 'count')], undefined);
+    this.search(ctx, entity, search, opts);
+  }
+
+  find<E>(ctx: QueryContext, entity: Type<E>, q: Query<E> = {}, opts?: QueryOptions): void {
+    this.select(ctx, entity, q.$select, opts);
+    this.search(ctx, entity, q, opts);
+  }
+
+  insert<E>(ctx: QueryContext, entity: Type<E>, payload: E | E[], opts?: QueryOptions): void {
+    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<E>(ctx: QueryContext, entity: Type<E>, q: QuerySearch<E>, payload: E, opts?: QueryOptions): void {
+    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);
+      ctx.append(`${this.escapeId(columnName)} = `);
+      this.formatPersistableValue(ctx, field, filledPayload[key]);
+    });
+
+    this.search(ctx, entity, q, opts);
+  }
+
+  upsert<E>(ctx: QueryContext, entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E): void {
+    const meta = getMeta(entity);
+    const update = this.getUpsertUpdateAssignments(ctx, meta, conflictPaths, payload, (name) => `VALUES(${name})`);
+
+    if (update) {
+      this.insert(ctx, entity, payload);
+      ctx.append(` ON DUPLICATE KEY UPDATE ${update}`);
+    } else {
+      const insertCtx = this.createContext();
+      this.insert(insertCtx, entity, payload);
+      ctx.append(insertCtx.sql.replace(/^INSERT/, 'INSERT IGNORE'));
+      insertCtx.values.forEach((val) => {
+        ctx.pushValue(val);
+      });
+    }
+  }
+
+  protected getUpsertUpdateAssignments<E>(
+    ctx: QueryContext,
+    meta: EntityMeta<E>,
+    conflictPaths: QueryConflictPaths<E>,
+    payload: E,
+    callback?: (columnName: string) => string,
+  ): string {
+    const [filledPayload] = fillOnFields(meta, payload, '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) {
+          return `${this.escapeId(columnName)} = ${callback(this.escapeId(columnName))}`;
+        }
+        const valCtx = this.createContext();
+        this.formatPersistableValue(valCtx, field, filledPayload[col]);
+        valCtx.values.forEach((val) => {
+          ctx.pushValue(val);
+        });
+        return `${this.escapeId(columnName)} = ${valCtx.sql}`;
+      })
+      .join(', ');
+  }
+
+  protected getUpsertConflictPathsStr<E>(meta: EntityMeta<E>, conflictPaths: QueryConflictPaths<E>): string {
+    return getKeys(conflictPaths)
+      .map((key) => {
+        const field = meta.fields[key];
+        const columnName = this.resolveColumnName(key, field);
+        return this.escapeId(columnName);
+      })
+      .join(', ');
+  }
+
+  delete<E>(ctx: QueryContext, entity: Type<E>, q: QuerySearch<E>, opts: QueryOptions = {}): void {
+    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];
+        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: string, forbidQualified?: boolean, addDot?: boolean): string {
+    return escapeSqlId(val, this.escapeIdChar, forbidQualified, addDot);
+  }
+
+  protected getPersistables<E>(
+    ctx: QueryContext,
+    meta: EntityMeta<E>,
+    payload: E | E[],
+    callbackKey: CallbackKey,
+  ): Record<string, unknown>[] {
+    const payloads = fillOnFields(meta, payload, callbackKey);
+    return payloads.map((it) => this.getPersistable(ctx, meta, it, callbackKey));
+  }
+
+  protected getPersistable<E>(
+    ctx: QueryContext,
+    meta: EntityMeta<E>,
+    payload: E,
+    callbackKey: CallbackKey,
+  ): Record<string, unknown> {
+    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]);
+        valCtx.values.forEach((val) => {
+          ctx.pushValue(val);
+        });
+        acc[key as string] = valCtx.sql;
+        return acc;
+      },
+      {} as Record<string, unknown>,
+    );
+  }
+
+  protected formatPersistableValue<E>(ctx: QueryContext, field: FieldOptions, value: unknown): void {
+    if (value instanceof QueryRaw) {
+      this.getRawValue(ctx, { value });
+      return;
+    }
+    if (field?.type === 'json' || field?.type === 'jsonb') {
+      ctx.addValue(value ? JSON.stringify(value) : null);
+      return;
+    }
+    if (field?.type === 'vector' && Array.isArray(value)) {
+      ctx.addValue(`[${value.join(',')}]`);
+      return;
+    }
+    ctx.addValue(value);
+  }
+
+  getRawValue(ctx: QueryContext, opts: QueryRawFnOptions & { value: QueryRaw; autoPrefixAlias?: boolean }) {
+    const { value, prefix = '', escapedPrefix, autoPrefixAlias } = opts;
+    if (typeof value.value === 'function') {
+      const res = value.value({
+        ...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(value.value));
+    }
+    const alias = value.alias;
+    if (alias) {
+      const fullAlias = autoPrefixAlias ? prefix + alias : alias;
+      // Replace dots with underscores for alias to avoid syntax errors
+      const safeAlias = fullAlias.replace(/\./g, '_');
+      const escapedFullAlias = this.escapeId(safeAlias, true);
+      ctx.append(' ' + escapedFullAlias);
+    }
+  }
+
+  abstract escape(value: unknown): string;
+}