Class SqlCompiler

SQL Compiler class Compiles query objects to SQL strings with proper escaping

Constructors

constructor

new SqlCompiler(dialect?: Dialect, options?: SqlCompilerOptions): SqlCompiler
Parameters
- Optionaldialect: Dialect
- Optionaloptions: SqlCompilerOptions
Returns SqlCompiler
- Defined in query-builders/sql-compiler.ts:109

Methods

setFieldMapping

setFieldMapping(fieldMapping: FieldMapping): void
Set the field mapping
Parameters
- fieldMapping: FieldMapping
Returns void
- Defined in query-builders/sql-compiler.ts:118

getColumnName

getColumnName(attributeName: string): string
Get the DB column name for an attribute
Parameters
- attributeName: string
Returns string
- Defined in query-builders/sql-compiler.ts:125

getAttributeName

getAttributeName(columnName: string): string
Get the attribute name for a DB column
Parameters
- columnName: string
Returns string
- Defined in query-builders/sql-compiler.ts:135

setDialect

setDialect(dialect: Dialect): void
Set the dialect
Parameters
- dialect: Dialect
Returns void
- Defined in query-builders/sql-compiler.ts:145

setOptions

setOptions(options: SqlCompilerOptions): void
Set compiler options
Parameters
- options: SqlCompilerOptions
Returns void
- Defined in query-builders/sql-compiler.ts:152

escape

escape(value: any): string
Escape a value for use in SQL
Parameters
- value: any
Returns string
- Defined in query-builders/sql-compiler.ts:159

escapeId

escapeId(identifier: unknown): string
Escape an identifier (column, table name)
Parameters
- identifier: unknown
Returns string
- Defined in query-builders/sql-compiler.ts:195

attributeToSql

attributeToSql(attr: any, tableAlias?: string): string
Convert an attribute expression to SQL Handles fn(), col(), literal(), and plain strings
Parameters
- attr: any
  The attribute value (string, FnExpression, ColExpression, LiteralExpression, or array)
- OptionaltableAlias: string
  Optional table alias to prepend to column names
Returns string
The SQL representation of the attribute
- Defined in query-builders/sql-compiler.ts:212

processAttribute

processAttribute(attr: any, tableAlias?: string): string
Process an attribute value (which could be a column name, fn expression, col expression, or literal) into a SQL expression string
Parameters
- attr: any
  The attribute value to process
- OptionaltableAlias: string
  Optional table alias to prefix column names with
Returns string
The SQL expression string
- Defined in query-builders/sql-compiler.ts:302

attributeToSqlWithAlias

attributeToSqlWithAlias(attr: any, tableAlias?: string): string
Convert an attribute to SQL with optional alias Handles formats like:
- 'columnName' -> "columnName"
- ['columnName', 'alias'] -> "columnName" AS "alias"
- [fn('COUNT', col('id')), 'count'] -> COUNT("id") AS "count"
- ['COUNT()', 'count'] -> COUNT() AS "count"
Parameters
- attr: any
  The attribute (string or array with alias)
- OptionaltableAlias: string
  Optional table alias
Returns string
SQL fragment with optional alias
- Defined in query-builders/sql-compiler.ts:388

compileWhere

compileWhere(
where: WhereOptions,
options?: { paramChar?: string },
): { sql: string; values: any[] }
Compile WHERE clause
Parameters
- where: WhereOptions
- Optionaloptions: { paramChar?: string }
Returns { sql: string; values: any[] }
- Defined in query-builders/sql-compiler.ts:412

compileOrder

compileOrder(order: Order): string
Compile ORDER BY clause
Parameters
- order: Order
Returns string
- Defined in query-builders/sql-compiler.ts:696

compileLimitOffset

compileLimitOffset(limit?: string | number, offset?: string | number): string
Compile LIMIT/OFFSET clause Handles SQLite which requires LIMIT when using OFFSET
Parameters
- Optionallimit: string | number
- Optionaloffset: string | number
Returns string
- Defined in query-builders/sql-compiler.ts:748

compileGroupBy

compileGroupBy(
    group?: string | string[],
    groupType?: "rollup" | "cube" | "grouping" | "none",
    groupingSets?: string[][],
): string
Compile GROUP BY clause Supports:
- Plain strings: 'role', 'userId'
- Arrays of strings: ['role', 'status']
- col() expressions: col('role'), col('table.column')
- fn() expressions: fn('UPPER', col('name'))
- literal expressions: literal('YEAR(created_at)')
- Array of mixed expressions
Parameters
- Optionalgroup: string | string[]
- OptionalgroupType: "rollup" | "cube" | "grouping" | "none"
- OptionalgroupingSets: string[][]
Returns string
Example
```
group: 'role'
group: ['role', 'status']
group: col('role')
group: [col('role'), fn('COUNT', col('id'))]
```
- Defined in query-builders/sql-compiler.ts:800

compileCTE

compileCTE(
    ctes?: {
        name: string;
        columns?: string[];
        query: string;
        recursive?: boolean;
    }[],
): string
Compile Common Table Expression (CTE) clause Supports both regular WITH and WITH RECURSIVE
Parameters
- Optionalctes: { name: string; columns?: string[]; query: string; recursive?: boolean }[]
Returns string
- Defined in query-builders/sql-compiler.ts:907

compileHaving

compileHaving(
having: any,
options?: { paramChar?: string },
): { sql: string; values: any[] }
Compile HAVING clause for aggregation filtering Similar to WHERE but specifically for aggregated results Supports all operators: Op.gt, Op.eq, Op.between, etc. Also supports direct aggregation functions: COUNT(), SUM(), AVG(), MAX(), MIN()
Parameters
- having: any
- Optionaloptions: { paramChar?: string }
Returns { sql: string; values: any[] }
- Defined in query-builders/sql-compiler.ts:940

compileSelect

compileSelect(
    options: {
        tableName: string;
        attributes?: string[] | { include?: string[]; exclude?: string[] };
        where?: WhereOptions;
        include?: IncludeOptions[];
        order?: Order;
        limit?: string | number;
        offset?: string | number;
        group?: string | string[];
        groupType?: "rollup" | "cube" | "grouping" | "none";
        groupingSets?: string[][];
        having?: WhereOptions;
        cte?: {
            name: string;
            columns?: string[];
            query: string;
            recursive?: boolean;
        }[];
        pivot?: PivotOptions;
        unpivot?: UnpivotOptions;
        pivotValues?: string[];
    },
): { sql: string; values: any[] }
Compile a full SELECT query
Parameters
- options: {
      tableName: string;
      attributes?: string[] | { include?: string[]; exclude?: string[] };
      where?: WhereOptions;
      include?: IncludeOptions[];
      order?: Order;
      limit?: string | number;
      offset?: string | number;
      group?: string | string[];
      groupType?: "rollup" | "cube" | "grouping" | "none";
      groupingSets?: string[][];
      having?: WhereOptions;
      cte?: {
          name: string;
          columns?: string[];
          query: string;
          recursive?: boolean;
      }[];
      pivot?: PivotOptions;
      unpivot?: UnpivotOptions;
      pivotValues?: string[];
  }
Returns { sql: string; values: any[] }
- Defined in query-builders/sql-compiler.ts:1248

compilePivot

compilePivot(
    options: {
        tableName: string;
        pivot: PivotOptions;
        groupBy: string | string[];
        where?: WhereOptions;
        order?: Order;
        limit?: string | number;
        offset?: string | number;
    },
): { sql: string; values: any[] }
Compile a PIVOT query - transform rows to columns
Parameters
- options: {
      tableName: string;
      pivot: PivotOptions;
      groupBy: string | string[];
      where?: WhereOptions;
      order?: Order;
      limit?: string | number;
      offset?: string | number;
  }
Returns { sql: string; values: any[] }
- Defined in query-builders/sql-compiler.ts:1543

compilePivotWithValues

compilePivotWithValues(
    options: {
        tableName: string;
        pivot: PivotOptions;
        pivotValues: string[];
        groupBy: string | string[];
        where?: WhereOptions;
        order?: Order;
        limit?: string | number;
        offset?: string | number;
    },
): { sql: string; values: any[] }
Compile a PIVOT query with specific pivot values (after they're resolved)
Parameters
- options: {
      tableName: string;
      pivot: PivotOptions;
      pivotValues: string[];
      groupBy: string | string[];
      where?: WhereOptions;
      order?: Order;
      limit?: string | number;
      offset?: string | number;
  }
Returns { sql: string; values: any[] }
- Defined in query-builders/sql-compiler.ts:1615

compileUnpivot

compileUnpivot(
    options: {
        tableName: string;
        unpivot: UnpivotOptions;
        where?: WhereOptions;
        order?: Order;
        limit?: string | number;
        offset?: string | number;
    },
): { sql: string; values: any[] }
Compile an UNPIVOT query - transform columns to rows
Parameters
- options: {
      tableName: string;
      unpivot: UnpivotOptions;
      where?: WhereOptions;
      order?: Order;
      limit?: string | number;
      offset?: string | number;
  }
Returns { sql: string; values: any[] }
- Defined in query-builders/sql-compiler.ts:1682

compileInsert

compileInsert(
    options: {
        tableName: string;
        values: Record<string, any>;
        returning?: boolean | string[];
    },
): { sql: string; values: any[] }
Compile an INSERT query
Parameters
- options: {
      tableName: string;
      values: Record<string, any>;
      returning?: boolean | string[];
  }
Returns { sql: string; values: any[] }
- Defined in query-builders/sql-compiler.ts:1737

compileUpdate

compileUpdate(
    options: {
        tableName: string;
        values: Record<string, any>;
        where: WhereOptions;
        limit?: number;
        returning?: boolean | string[];
    },
): { sql: string; values: any[] }
Compile an UPDATE query
Parameters
- options: {
      tableName: string;
      values: Record<string, any>;
      where: WhereOptions;
      limit?: number;
      returning?: boolean | string[];
  }
Returns { sql: string; values: any[] }
- Defined in query-builders/sql-compiler.ts:1765

compileDelete

compileDelete(
    options: {
        tableName: string;
        where: WhereOptions;
        limit?: number;
        returning?: boolean | string[];
    },
): { sql: string; values: any[] }
Compile a DELETE query
Parameters
- options: {
      tableName: string;
      where: WhereOptions;
      limit?: number;
      returning?: boolean | string[];
  }
Returns { sql: string; values: any[] }
- Defined in query-builders/sql-compiler.ts:1806

compileUnion

compileUnion(
    options: {
        main: {
            tableName: string;
            attributes?: string[] | { include?: string[]; exclude?: string[] };
            where?: WhereOptions;
            include?: IncludeOptions[];
            order?: Order;
            limit?: string | number;
            offset?: string | number;
        };
        union: {
            type: "UNION"
            | "UNION ALL"
            | "EXCEPT"
            | "INTERSECT";
            model?: ModelStatic<any>;
            tableName?: string;
            where?: WhereOptions;
            attributes?: string[] | { include?: string[]; exclude?: string[] };
            order?: Order;
            limit?: string | number;
            offset?: string | number;
            include?: IncludeOptions[];
        }[];
        order?: Order;
        limit?: string
        | number;
        offset?: string | number;
    },
): { sql: string; values: any[] }
Compile a UNION/EXCEPT/INTERSECT query Supports combining multiple queries with UNION, UNION ALL, EXCEPT, or INTERSECT
Parameters
- options: {
      main: {
          tableName: string;
          attributes?: string[] | { include?: string[]; exclude?: string[] };
          where?: WhereOptions;
          include?: IncludeOptions[];
          order?: Order;
          limit?: string | number;
          offset?: string | number;
      };
      union: {
          type: "UNION"
          | "UNION ALL"
          | "EXCEPT"
          | "INTERSECT";
          model?: ModelStatic<any>;
          tableName?: string;
          where?: WhereOptions;
          attributes?: string[] | { include?: string[]; exclude?: string[] };
          order?: Order;
          limit?: string | number;
          offset?: string | number;
          include?: IncludeOptions[];
      }[];
      order?: Order;
      limit?: string
      | number;
      offset?: string | number;
  }
  - main: {
        tableName: string;
        attributes?: string[] | { include?: string[]; exclude?: string[] };
        where?: WhereOptions;
        include?: IncludeOptions[];
        order?: Order;
        limit?: string | number;
        offset?: string | number;
    }
    
    The main query (uses same structure as compileSelect)
  - union: {
        type: "UNION" | "UNION ALL" | "EXCEPT" | "INTERSECT";
        model?: ModelStatic<any>;
        tableName?: string;
        where?: WhereOptions;
        attributes?: string[] | { include?: string[]; exclude?: string[] };
        order?: Order;
        limit?: string | number;
        offset?: string | number;
        include?: IncludeOptions[];
    }[]
    
    Array of union queries
  - Optionalorder?: Order
    
    Order by for the combined result
  - Optionallimit?: string | number
    
    Limit for the combined result
  - Optionaloffset?: string | number
    
    Offset for the combined result
Returns { sql: string; values: any[] }
- Defined in query-builders/sql-compiler.ts:1839

compileExcept

compileExcept(
    mainQuery: {
        tableName: string;
        attributes?: string[] | { include?: string[]; exclude?: string[] };
        where?: WhereOptions;
        include?: IncludeOptions[];
    },
    exceptQuery: {
        tableName: string;
        attributes?: string[] | { include?: string[]; exclude?: string[] };
        where?: WhereOptions;
        include?: IncludeOptions[];
    },
    options?: {
        order?: Order;
        limit?: string | number;
        offset?: string | number;
    },
): { sql: string; values: any[] }
Compile an EXCEPT query - returns rows from main query that don't exist in except query
Parameters
- mainQuery: {
      tableName: string;
      attributes?: string[] | { include?: string[]; exclude?: string[] };
      where?: WhereOptions;
      include?: IncludeOptions[];
  }
- exceptQuery: {
      tableName: string;
      attributes?: string[] | { include?: string[]; exclude?: string[] };
      where?: WhereOptions;
      include?: IncludeOptions[];
  }
- Optionaloptions: { order?: Order; limit?: string | number; offset?: string | number }
Returns { sql: string; values: any[] }
- Defined in query-builders/sql-compiler.ts:1934

compileIntersect

compileIntersect(
    mainQuery: {
        tableName: string;
        attributes?: string[] | { include?: string[]; exclude?: string[] };
        where?: WhereOptions;
        include?: IncludeOptions[];
    },
    intersectQuery: {
        tableName: string;
        attributes?: string[] | { include?: string[]; exclude?: string[] };
        where?: WhereOptions;
        include?: IncludeOptions[];
    },
    options?: {
        order?: Order;
        limit?: string | number;
        offset?: string | number;
    },
): { sql: string; values: any[] }
Compile an INTERSECT query - returns rows that exist in both queries
Parameters
- mainQuery: {
      tableName: string;
      attributes?: string[] | { include?: string[]; exclude?: string[] };
      where?: WhereOptions;
      include?: IncludeOptions[];
  }
- intersectQuery: {
      tableName: string;
      attributes?: string[] | { include?: string[]; exclude?: string[] };
      where?: WhereOptions;
      include?: IncludeOptions[];
  }
- Optionaloptions: { order?: Order; limit?: string | number; offset?: string | number }
Returns { sql: string; values: any[] }
- Defined in query-builders/sql-compiler.ts:1973

formatForDialect

formatForDialect(sql: string, dialect: string): string
Format SQL for different dialects
Parameters
- sql: string
- dialect: string
Returns string
- Defined in query-builders/sql-compiler.ts:2012

compilePartitionBy

compilePartitionBy(partitionBy: string | string[] | undefined): string
Compile PARTITION BY clause
Parameters
- partitionBy: string | string[] | undefined
Returns string
- Defined in query-builders/sql-compiler.ts:2363

compileWindowFrame

compileWindowFrame(windowFrame: WindowFrame | undefined): string
Compile window frame specification Examples:
- ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING
- RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
- GROUPS 2 PRECEDING AND CURRENT ROW
Parameters
- windowFrame: WindowFrame | undefined
Returns string
- Defined in query-builders/sql-compiler.ts:2389

compileLockOptions

compileLockOptions(lock: any, dialect?: string): string
Compile lock options for row-level locking.

Delegates to the shared dialect lock compiler so this and each dialect's own buildSelectQuery() can never disagree about what a given lock shape means. Supports true, a level string, and the { level, nowait, skipLocked, of } object form; throws when the named dialect cannot express the requested lock.
Parameters
- lock: any
  Lock options
- dialect: string = 'postgres'
  The database dialect
Returns string
The compiled lock SQL clause, or an empty string for no lock and for dialects with no trailing locking clause (SQLite, SQL Server, ...)
- Defined in query-builders/sql-compiler.ts:2446

compileOverClause

compileOverClause(options: WindowFunctionOptions): string
Compile OVER clause with partition, order, and window frame
Parameters
- options: WindowFunctionOptions
Returns string
- Defined in query-builders/sql-compiler.ts:2457

compileWindowFunction

compileWindowFunction(
    functionName: string,
    args?: any[],
    options?: WindowFunctionOptions,
): string
Compile a window function expression
Parameters
- functionName: string
  The window function name (ROW_NUMBER, RANK, etc.)
- args: any[] = []
  Arguments to the window function
- options: WindowFunctionOptions = {}
  Window function options
Returns string
The compiled SQL expression
- Defined in query-builders/sql-compiler.ts:2480

prettyPrint

prettyPrint(sql: string): string
Pretty print SQL
Parameters
- sql: string
Returns string
- Defined in query-builders/sql-compiler.ts:2497

Class SqlCompiler

Index

Constructors

Methods

Constructors

constructor

Parameters

Returns SqlCompiler

Methods

setFieldMapping

Parameters

Returns void

getColumnName

Parameters

Returns string

getAttributeName

Parameters

Returns string

setDialect

Parameters

Returns void

setOptions

Parameters

Returns void

escape

Parameters

Returns string

escapeId

Parameters

Returns string

attributeToSql

Parameters

Returns string

processAttribute

Parameters

Returns string

attributeToSqlWithAlias

Parameters

Returns string

compileWhere

Parameters

Returns { sql: string; values: any[] }

compileOrder

Parameters

Returns string

compileLimitOffset

Parameters

Returns string

compileGroupBy

Parameters

Returns string

Example

compileCTE

Parameters

Returns string

compileHaving

Parameters

Returns { sql: string; values: any[] }

compileSelect

Parameters

Returns { sql: string; values: any[] }

compilePivot

Parameters

Returns { sql: string; values: any[] }

compilePivotWithValues

Parameters

Returns { sql: string; values: any[] }

compileUnpivot

Parameters

Returns { sql: string; values: any[] }

compileInsert

Parameters

Returns { sql: string; values: any[] }

compileUpdate

Parameters

Returns { sql: string; values: any[] }

compileDelete

Parameters

Returns { sql: string; values: any[] }

compileUnion

main: {
tableName: string;
attributes?: string[] | { include?: string[]; exclude?: string[] };
where?: WhereOptions;
include?: IncludeOptions[];
order?: Order;
limit?: string | number;
offset?: string | number;
}

union: {
type: "UNION" | "UNION ALL" | "EXCEPT" | "INTERSECT";
model?: ModelStatic<any>;
tableName?: string;
where?: WhereOptions;
attributes?: string[] | { include?: string[]; exclude?: string[] };
order?: Order;
limit?: string | number;
offset?: string | number;
include?: IncludeOptions[];
}[]

`Optional`order?: Order

`Optional`limit?: string | number

`Optional`offset?: string | number