metal-orm 1.0.14 → 1.0.16

package/src/core/dialect/mssql/index.ts

@@ -1,16 +1,18 @@
-import { CompilerContext, Dialect } from '../abstract.js';
-import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query.js';
-import { JsonPathNode } from '../../ast/expression.js';
+import { CompilerContext, Dialect } from '../abstract.js';
+import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query.js';
+import { JsonPathNode } from '../../ast/expression.js';
+import { MssqlFunctionStrategy } from './functions.js';
 
 /**
  * Microsoft SQL Server dialect implementation
  */
 export class SqlServerDialect extends Dialect {
+  protected readonly dialect = 'mssql';
   /**
    * Creates a new SqlServerDialect instance
    */
   public constructor() {
-    super();
+    super(new MssqlFunctionStrategy());
   }
 
   /**
@@ -42,36 +44,36 @@ export class SqlServerDialect extends Dialect {
     return `@p${index}`;
   }
 
-  /**
-   * Compiles SELECT query AST to SQL Server SQL
-   * @param ast - Query AST
-   * @param ctx - Compiler context
-   * @returns SQL Server SQL string
-   */
-  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
-    const hasSetOps = !!(ast.setOps && ast.setOps.length);
-    const ctes = this.compileCtes(ast, ctx);
-
-    const baseAst: SelectQueryNode = hasSetOps
-      ? { ...ast, setOps: undefined, orderBy: undefined, limit: undefined, offset: undefined }
-      : ast;
-
-    const baseSelect = this.compileSelectCore(baseAst, ctx);
-
-    if (!hasSetOps) {
-      return `${ctes}${baseSelect}`;
-    }
-
-    const compound = ast.setOps!
-      .map(op => `${op.operator} ${this.wrapSetOperand(this.compileSelectAst(op.query, ctx))}`)
-      .join(' ');
-
-    const orderBy = this.compileOrderBy(ast);
-    const pagination = this.compilePagination(ast, orderBy);
-    const combined = `${this.wrapSetOperand(baseSelect)} ${compound}`;
-    const tail = pagination || orderBy;
-    return `${ctes}${combined}${tail}`;
-  }
+  /**
+   * Compiles SELECT query AST to SQL Server SQL
+   * @param ast - Query AST
+   * @param ctx - Compiler context
+   * @returns SQL Server SQL string
+   */
+  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
+    const hasSetOps = !!(ast.setOps && ast.setOps.length);
+    const ctes = this.compileCtes(ast, ctx);
+
+    const baseAst: SelectQueryNode = hasSetOps
+      ? { ...ast, setOps: undefined, orderBy: undefined, limit: undefined, offset: undefined }
+      : ast;
+
+    const baseSelect = this.compileSelectCore(baseAst, ctx);
+
+    if (!hasSetOps) {
+      return `${ctes}${baseSelect}`;
+    }
+
+    const compound = ast.setOps!
+      .map(op => `${op.operator} ${this.wrapSetOperand(this.compileSelectAst(op.query, ctx))}`)
+      .join(' ');
+
+    const orderBy = this.compileOrderBy(ast);
+    const pagination = this.compilePagination(ast, orderBy);
+    const combined = `${this.wrapSetOperand(baseSelect)} ${compound}`;
+    const tail = pagination || orderBy;
+    return `${ctes}${combined}${tail}`;
+  }
 
   protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
     const table = this.quoteIdentifier(ast.into.name);
@@ -92,95 +94,95 @@ export class SqlServerDialect extends Dialect {
     return `UPDATE ${table} SET ${assignments}${whereClause};`;
   }
 
-  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.from.name);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    return `DELETE FROM ${table}${whereClause};`;
-  }
-
-  private compileSelectCore(ast: SelectQueryNode, ctx: CompilerContext): string {
-    const columns = ast.columns.map(c => {
-      let expr = '';
-      if (c.type === 'Function') {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === 'Column') {
-        expr = `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`;
-      } else if (c.type === 'ScalarSubquery') {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === 'WindowFunction') {
-        expr = this.compileOperand(c, ctx);
-      }
-
-      if (c.alias) {
-        if (c.alias.includes('(')) return c.alias;
-        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
-      }
-      return expr;
-    }).join(', ');
-
-    const distinct = ast.distinct ? 'DISTINCT ' : '';
-    const from = `${this.quoteIdentifier(ast.from.name)}`;
-
-    const joins = ast.joins.map(j => {
-      const table = this.quoteIdentifier(j.table.name);
-      const cond = this.compileExpression(j.condition, ctx);
-      return `${j.kind} JOIN ${table} ON ${cond}`;
-    }).join(' ');
-    const whereClause = this.compileWhere(ast.where, ctx);
-
-    const groupBy = ast.groupBy && ast.groupBy.length > 0
-      ? ' GROUP BY ' + ast.groupBy.map(c => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`).join(', ')
-      : '';
-
-    const having = ast.having
-      ? ` HAVING ${this.compileExpression(ast.having, ctx)}`
-      : '';
-
-    const orderBy = this.compileOrderBy(ast);
-    const pagination = this.compilePagination(ast, orderBy);
-
-    if (pagination) {
-      return `SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${pagination}`;
-    }
-
-    return `SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy}`;
-  }
-
-  private compileOrderBy(ast: SelectQueryNode): string {
-    if (!ast.orderBy || ast.orderBy.length === 0) return '';
-    return ' ORDER BY ' + ast.orderBy
-      .map(o => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`)
-      .join(', ');
-  }
-
-  private compilePagination(ast: SelectQueryNode, orderBy: string): string {
-    const hasLimit = ast.limit !== undefined;
-    const hasOffset = ast.offset !== undefined;
-    if (!hasLimit && !hasOffset) return '';
-
-    const off = ast.offset ?? 0;
-    const orderClause = orderBy || ' ORDER BY (SELECT NULL)';
-    let pagination = `${orderClause} OFFSET ${off} ROWS`;
-    if (hasLimit) {
-      pagination += ` FETCH NEXT ${ast.limit} ROWS ONLY`;
-    }
-    return pagination;
-  }
-
-  private compileCtes(ast: SelectQueryNode, ctx: CompilerContext): string {
-    if (!ast.ctes || ast.ctes.length === 0) return '';
-    // MSSQL does not use RECURSIVE keyword, but supports recursion when CTE references itself.
-    const defs = ast.ctes.map(cte => {
-      const name = this.quoteIdentifier(cte.name);
-      const cols = cte.columns ? `(${cte.columns.map(c => this.quoteIdentifier(c)).join(', ')})` : '';
-      const query = this.compileSelectAst(this.normalizeSelectAst(cte.query), ctx).trim().replace(/;$/, '');
-      return `${name}${cols} AS (${query})`;
-    }).join(', ');
-    return `WITH ${defs} `;
-  }
-
-  private wrapSetOperand(sql: string): string {
-    const trimmed = sql.trim().replace(/;$/, '');
-    return `(${trimmed})`;
-  }
-}
+  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
+    const table = this.quoteIdentifier(ast.from.name);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    return `DELETE FROM ${table}${whereClause};`;
+  }
+
+  private compileSelectCore(ast: SelectQueryNode, ctx: CompilerContext): string {
+    const columns = ast.columns.map(c => {
+      let expr = '';
+      if (c.type === 'Function') {
+        expr = this.compileOperand(c, ctx);
+      } else if (c.type === 'Column') {
+        expr = `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`;
+      } else if (c.type === 'ScalarSubquery') {
+        expr = this.compileOperand(c, ctx);
+      } else if (c.type === 'WindowFunction') {
+        expr = this.compileOperand(c, ctx);
+      }
+
+      if (c.alias) {
+        if (c.alias.includes('(')) return c.alias;
+        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
+      }
+      return expr;
+    }).join(', ');
+
+    const distinct = ast.distinct ? 'DISTINCT ' : '';
+    const from = `${this.quoteIdentifier(ast.from.name)}`;
+
+    const joins = ast.joins.map(j => {
+      const table = this.quoteIdentifier(j.table.name);
+      const cond = this.compileExpression(j.condition, ctx);
+      return `${j.kind} JOIN ${table} ON ${cond}`;
+    }).join(' ');
+    const whereClause = this.compileWhere(ast.where, ctx);
+
+    const groupBy = ast.groupBy && ast.groupBy.length > 0
+      ? ' GROUP BY ' + ast.groupBy.map(c => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`).join(', ')
+      : '';
+
+    const having = ast.having
+      ? ` HAVING ${this.compileExpression(ast.having, ctx)}`
+      : '';
+
+    const orderBy = this.compileOrderBy(ast);
+    const pagination = this.compilePagination(ast, orderBy);
+
+    if (pagination) {
+      return `SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${pagination}`;
+    }
+
+    return `SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy}`;
+  }
+
+  private compileOrderBy(ast: SelectQueryNode): string {
+    if (!ast.orderBy || ast.orderBy.length === 0) return '';
+    return ' ORDER BY ' + ast.orderBy
+      .map(o => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`)
+      .join(', ');
+  }
+
+  private compilePagination(ast: SelectQueryNode, orderBy: string): string {
+    const hasLimit = ast.limit !== undefined;
+    const hasOffset = ast.offset !== undefined;
+    if (!hasLimit && !hasOffset) return '';
+
+    const off = ast.offset ?? 0;
+    const orderClause = orderBy || ' ORDER BY (SELECT NULL)';
+    let pagination = `${orderClause} OFFSET ${off} ROWS`;
+    if (hasLimit) {
+      pagination += ` FETCH NEXT ${ast.limit} ROWS ONLY`;
+    }
+    return pagination;
+  }
+
+  private compileCtes(ast: SelectQueryNode, ctx: CompilerContext): string {
+    if (!ast.ctes || ast.ctes.length === 0) return '';
+    // MSSQL does not use RECURSIVE keyword, but supports recursion when CTE references itself.
+    const defs = ast.ctes.map(cte => {
+      const name = this.quoteIdentifier(cte.name);
+      const cols = cte.columns ? `(${cte.columns.map(c => this.quoteIdentifier(c)).join(', ')})` : '';
+      const query = this.compileSelectAst(this.normalizeSelectAst(cte.query), ctx).trim().replace(/;$/, '');
+      return `${name}${cols} AS (${query})`;
+    }).join(', ');
+    return `WITH ${defs} `;
+  }
+
+  private wrapSetOperand(sql: string): string {
+    const trimmed = sql.trim().replace(/;$/, '');
+    return `(${trimmed})`;
+  }
+}

package/src/core/dialect/mysql/functions.ts

@@ -0,0 +1,101 @@
+import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
+import { FunctionRenderContext } from '../../functions/types.js';
+import { LiteralNode } from '../../ast/expression.js';
+
+export class MysqlFunctionStrategy extends StandardFunctionStrategy {
+    constructor() {
+        super();
+        this.registerOverrides();
+    }
+
+    private registerOverrides() {
+        // Override Standard/Abstract definitions with MySQL specifics
+
+        // Date/Time functions
+        this.add('NOW', () => `NOW()`);
+        this.add('CURRENT_DATE', () => `CURDATE()`);
+        this.add('CURRENT_TIME', () => `CURTIME()`);
+        this.add('UTC_NOW', () => `UTC_TIMESTAMP()`);
+
+        this.add('EXTRACT', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('EXTRACT expects 2 arguments (part, date)');
+            const [part, date] = compiledArgs;
+            const partClean = part.replace(/['"]/g, '');
+            return `EXTRACT(${partClean} FROM ${date})`;
+        });
+
+        this.add('YEAR', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('YEAR expects 1 argument');
+            return `YEAR(${compiledArgs[0]})`;
+        });
+
+        this.add('MONTH', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('MONTH expects 1 argument');
+            return `MONTH(${compiledArgs[0]})`;
+        });
+
+        this.add('DAY', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('DAY expects 1 argument');
+            return `DAY(${compiledArgs[0]})`;
+        });
+
+        this.add('DATE_ADD', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 3) throw new Error('DATE_ADD expects 3 arguments (date, interval, unit)');
+            const [date, interval] = compiledArgs;
+            const unitArg = node.args[2] as LiteralNode;
+            const unitClean = String(unitArg.value).replace(/['"]/g, '').toUpperCase();
+            return `DATE_ADD(${date}, INTERVAL ${interval} ${unitClean})`;
+        });
+
+        this.add('DATE_SUB', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 3) throw new Error('DATE_SUB expects 3 arguments (date, interval, unit)');
+            const [date, interval] = compiledArgs;
+            const unitArg = node.args[2] as LiteralNode;
+            const unitClean = String(unitArg.value).replace(/['"]/g, '').toUpperCase();
+            return `DATE_SUB(${date}, INTERVAL ${interval} ${unitClean})`;
+        });
+
+        this.add('DATE_DIFF', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_DIFF expects 2 arguments');
+            const [date1, date2] = compiledArgs;
+            return `DATEDIFF(${date1}, ${date2})`;
+        });
+
+        this.add('DATE_FORMAT', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_FORMAT expects 2 arguments');
+            const [date, format] = compiledArgs;
+            return `DATE_FORMAT(${date}, ${format})`;
+        });
+
+        this.add('END_OF_MONTH', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('END_OF_MONTH expects 1 argument');
+            return `LAST_DAY(${compiledArgs[0]})`;
+        });
+
+        this.add('DAY_OF_WEEK', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('DAY_OF_WEEK expects 1 argument');
+            return `DAYOFWEEK(${compiledArgs[0]})`;
+        });
+
+        this.add('WEEK_OF_YEAR', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('WEEK_OF_YEAR expects 1 argument');
+            return `WEEKOFYEAR(${compiledArgs[0]})`;
+        });
+
+        this.add('DATE_TRUNC', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_TRUNC expects 2 arguments (part, date)');
+            const [, date] = compiledArgs;
+            const partArg = node.args[0] as LiteralNode;
+            const partClean = String(partArg.value).replace(/['"]/g, '').toLowerCase();
+            // MySQL doesn't have DATE_TRUNC, use DATE_FORMAT workaround
+            if (partClean === 'year') {
+                return `DATE_FORMAT(${date}, '%Y-01-01')`;
+            } else if (partClean === 'month') {
+                return `DATE_FORMAT(${date}, '%Y-%m-01')`;
+            } else if (partClean === 'day') {
+                return `DATE(${date})`;
+            }
+            return `DATE(${date})`;
+        });
+    }
+}

package/src/core/dialect/mysql/index.ts

@@ -1,15 +1,17 @@
-import { JsonPathNode } from '../../ast/expression.js';
-import { SqlDialectBase } from '../base/sql-dialect.js';
-
-/**
- * MySQL dialect implementation
- */
-export class MySqlDialect extends SqlDialectBase {
-  /**
-   * Creates a new MySqlDialect instance
-   */
-  public constructor() {
-    super();
+import { JsonPathNode } from '../../ast/expression.js';
+import { SqlDialectBase } from '../base/sql-dialect.js';
+import { MysqlFunctionStrategy } from './functions.js';
+
+/**
+ * MySQL dialect implementation
+ */
+export class MySqlDialect extends SqlDialectBase {
+  protected readonly dialect = 'mysql';
+  /**
+   * Creates a new MySqlDialect instance
+   */
+  public constructor() {
+    super(new MysqlFunctionStrategy());
   }
 
   /**
@@ -26,9 +28,9 @@ export class MySqlDialect extends SqlDialectBase {
    * @param node - JSON path node
    * @returns MySQL JSON path expression
    */
-  protected compileJsonPath(node: JsonPathNode): string {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    // MySQL 5.7+ uses col->'$.path'
-    return `${col}->'${node.path}'`;
-  }
-}
+  protected compileJsonPath(node: JsonPathNode): string {
+    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    // MySQL 5.7+ uses col->'$.path'
+    return `${col}->'${node.path}'`;
+  }
+}

package/src/core/dialect/postgres/functions.ts

@@ -0,0 +1,95 @@
+import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
+import { FunctionRenderContext } from '../../functions/types.js';
+import { LiteralNode } from '../../ast/expression.js';
+
+export class PostgresFunctionStrategy extends StandardFunctionStrategy {
+    constructor() {
+        super();
+        this.registerOverrides();
+    }
+
+    private registerOverrides() {
+        // Override Standard/Abstract definitions with PostgreSQL specifics
+
+        // Date/Time functions
+        this.add('UTC_NOW', () => `(NOW() AT TIME ZONE 'UTC')`);
+        this.add('UNIX_TIMESTAMP', () => `EXTRACT(EPOCH FROM NOW())::INTEGER`);
+        this.add('FROM_UNIXTIME', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('FROM_UNIXTIME expects 1 argument');
+            return `to_timestamp(${compiledArgs[0]})`;
+        });
+
+        this.add('EXTRACT', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('EXTRACT expects 2 arguments (part, date)');
+            const [part, date] = compiledArgs;
+            const partClean = part.replace(/['"]/g, '');
+            return `EXTRACT(${partClean} FROM ${date})`;
+        });
+
+        this.add('YEAR', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('YEAR expects 1 argument');
+            return `EXTRACT(YEAR FROM ${compiledArgs[0]})`;
+        });
+
+        this.add('MONTH', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('MONTH expects 1 argument');
+            return `EXTRACT(MONTH FROM ${compiledArgs[0]})`;
+        });
+
+        this.add('DAY', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('DAY expects 1 argument');
+            return `EXTRACT(DAY FROM ${compiledArgs[0]})`;
+        });
+
+        this.add('DATE_ADD', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 3) throw new Error('DATE_ADD expects 3 arguments (date, interval, unit)');
+            const [date, interval] = compiledArgs;
+            const unitArg = node.args[2] as LiteralNode;
+            const unitClean = String(unitArg.value).replace(/['"]/g, '').toLowerCase();
+            return `(${date} + (${interval} || ' ${unitClean}')::INTERVAL)`;
+        });
+
+        this.add('DATE_SUB', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 3) throw new Error('DATE_SUB expects 3 arguments (date, interval, unit)');
+            const [date, interval] = compiledArgs;
+            const unitArg = node.args[2] as LiteralNode;
+            const unitClean = String(unitArg.value).replace(/['"]/g, '').toLowerCase();
+            return `(${date} - (${interval} || ' ${unitClean}')::INTERVAL)`;
+        });
+
+        this.add('DATE_DIFF', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_DIFF expects 2 arguments');
+            const [date1, date2] = compiledArgs;
+            return `(${date1}::DATE - ${date2}::DATE)`;
+        });
+
+        this.add('DATE_FORMAT', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_FORMAT expects 2 arguments');
+            const [date, format] = compiledArgs;
+            return `TO_CHAR(${date}, ${format})`;
+        });
+
+        this.add('END_OF_MONTH', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('END_OF_MONTH expects 1 argument');
+            return `(date_trunc('month', ${compiledArgs[0]}) + interval '1 month' - interval '1 day')::DATE`;
+        });
+
+        this.add('DAY_OF_WEEK', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('DAY_OF_WEEK expects 1 argument');
+            return `EXTRACT(DOW FROM ${compiledArgs[0]})`;
+        });
+
+        this.add('WEEK_OF_YEAR', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('WEEK_OF_YEAR expects 1 argument');
+            return `EXTRACT(WEEK FROM ${compiledArgs[0]})`;
+        });
+
+        this.add('DATE_TRUNC', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_TRUNC expects 2 arguments (part, date)');
+            const [, date] = compiledArgs;
+            const partArg = node.args[0] as LiteralNode;
+            const partClean = String(partArg.value).replace(/['"]/g, '').toLowerCase();
+            return `DATE_TRUNC('${partClean}', ${date})`;
+        });
+    }
+}

package/src/core/dialect/postgres/index.ts

@@ -1,16 +1,18 @@
-import { CompilerContext } from '../abstract.js';
-import { JsonPathNode, ColumnNode } from '../../ast/expression.js';
-import { SqlDialectBase } from '../base/sql-dialect.js';
-
-/**
- * PostgreSQL dialect implementation
- */
-export class PostgresDialect extends SqlDialectBase {
-  /**
-   * Creates a new PostgresDialect instance
-   */
-  public constructor() {
-    super();
+import { CompilerContext } from '../abstract.js';
+import { JsonPathNode, ColumnNode } from '../../ast/expression.js';
+import { SqlDialectBase } from '../base/sql-dialect.js';
+import { PostgresFunctionStrategy } from './functions.js';
+
+/**
+ * PostgreSQL dialect implementation
+ */
+export class PostgresDialect extends SqlDialectBase {
+  protected readonly dialect = 'postgres';
+  /**
+   * Creates a new PostgresDialect instance
+   */
+  public constructor() {
+    super(new PostgresFunctionStrategy());
   }
 
   /**
@@ -27,19 +29,19 @@ export class PostgresDialect extends SqlDialectBase {
    * @param node - JSON path node
    * @returns PostgreSQL JSON path expression
    */
-  protected compileJsonPath(node: JsonPathNode): string {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    // Postgres uses col->>'path' for text extraction
-    return `${col}->>'${node.path}'`;
-  }
+  protected compileJsonPath(node: JsonPathNode): string {
+    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    // Postgres uses col->>'path' for text extraction
+    return `${col}->>'${node.path}'`;
+  }
 
-  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
-    if (!returning || returning.length === 0) return '';
-    const columns = this.formatReturningColumns(returning);
-    return ` RETURNING ${columns}`;
-  }
-
-  supportsReturning(): boolean {
-    return true;
-  }
-}
+  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
+    if (!returning || returning.length === 0) return '';
+    const columns = this.formatReturningColumns(returning);
+    return ` RETURNING ${columns}`;
+  }
+
+  supportsReturning(): boolean {
+    return true;
+  }
+}