@hypequery/clickhouse 1.6.2 → 2.0.0

package/dist/core/features/query-modifiers.d.ts

@@ -1,116 +1,17 @@
 import type { BuilderState, SchemaDefinition } from '../types/builder-state.js';
 import { QueryBuilder } from '../query-builder.js';
-import { OrderDirection } from '../../types/index.js';
+import { OrderDirection, type SelectQueryNode } from '../../types/index.js';
 export declare class QueryModifiersFeature<Schema extends SchemaDefinition<Schema>, State extends BuilderState<Schema, string, any, keyof Schema, Partial<Record<string, keyof Schema>>>> {
     private builder;
     constructor(builder: QueryBuilder<Schema, State>);
-    addGroupBy(columns: string | string[]): {
-        groupBy: string[];
-        select?: (string | keyof State["output"])[] | undefined;
-        where?: import("../../types/base.js").WhereCondition[];
-        having?: string[];
-        limit?: number;
-        offset?: number;
-        distinct?: boolean;
-        orderBy?: {
-            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
-            direction: OrderDirection;
-        }[] | undefined;
-        joins?: import("../../types/base.js").JoinClause[];
-        parameters?: any[];
-        ctes?: string[];
-        unionQueries?: string[];
-        settings?: import("@clickhouse/client-common").ClickHouseSettings;
-    };
-    addLimit(count: number): {
-        limit: number;
-        select?: (string | keyof State["output"])[] | undefined;
-        where?: import("../../types/base.js").WhereCondition[];
-        groupBy?: string[];
-        having?: string[];
-        offset?: number;
-        distinct?: boolean;
-        orderBy?: {
-            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
-            direction: OrderDirection;
-        }[] | undefined;
-        joins?: import("../../types/base.js").JoinClause[];
-        parameters?: any[];
-        ctes?: string[];
-        unionQueries?: string[];
-        settings?: import("@clickhouse/client-common").ClickHouseSettings;
-    };
-    addOffset(count: number): {
-        offset: number;
-        select?: (string | keyof State["output"])[] | undefined;
-        where?: import("../../types/base.js").WhereCondition[];
-        groupBy?: string[];
-        having?: string[];
-        limit?: number;
-        distinct?: boolean;
-        orderBy?: {
-            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
-            direction: OrderDirection;
-        }[] | undefined;
-        joins?: import("../../types/base.js").JoinClause[];
-        parameters?: any[];
-        ctes?: string[];
-        unionQueries?: string[];
-        settings?: import("@clickhouse/client-common").ClickHouseSettings;
-    };
-    addOrderBy(column: string, direction?: OrderDirection): {
-        orderBy: {
-            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
-            direction: OrderDirection;
-        }[];
-        select?: (string | keyof State["output"])[] | undefined;
-        where?: import("../../types/base.js").WhereCondition[];
-        groupBy?: string[];
-        having?: string[];
-        limit?: number;
-        offset?: number;
-        distinct?: boolean;
-        joins?: import("../../types/base.js").JoinClause[];
-        parameters?: any[];
-        ctes?: string[];
-        unionQueries?: string[];
-        settings?: import("@clickhouse/client-common").ClickHouseSettings;
-    };
-    addHaving(condition: string, parameters?: any[]): {
-        having: string[];
-        parameters: any[] | undefined;
-        select?: (string | keyof State["output"])[] | undefined;
-        where?: import("../../types/base.js").WhereCondition[];
-        groupBy?: string[];
-        limit?: number;
-        offset?: number;
-        distinct?: boolean;
-        orderBy?: {
-            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
-            direction: OrderDirection;
-        }[] | undefined;
-        joins?: import("../../types/base.js").JoinClause[];
-        ctes?: string[];
-        unionQueries?: string[];
-        settings?: import("@clickhouse/client-common").ClickHouseSettings;
-    };
-    setDistinct(): {
-        distinct: boolean;
-        select?: (string | keyof State["output"])[] | undefined;
-        where?: import("../../types/base.js").WhereCondition[];
-        groupBy?: string[];
-        having?: string[];
-        limit?: number;
-        offset?: number;
-        orderBy?: {
-            column: keyof State["output"] | import("../../types/schema.js").TableColumn<Schema>;
-            direction: OrderDirection;
-        }[] | undefined;
-        joins?: import("../../types/base.js").JoinClause[];
-        parameters?: any[];
-        ctes?: string[];
-        unionQueries?: string[];
-        settings?: import("@clickhouse/client-common").ClickHouseSettings;
-    };
+    addGroupBy(columns: string | string[]): SelectQueryNode<State['output'], Schema>;
+    addArrayJoin(type: 'ARRAY' | 'LEFT ARRAY', expression: string): SelectQueryNode<State['output'], Schema>;
+    addLimit(count: number): SelectQueryNode<State['output'], Schema>;
+    addLimitBy(limit: number, by: string | string[]): SelectQueryNode<State['output'], Schema>;
+    addOffset(count: number): SelectQueryNode<State['output'], Schema>;
+    addOrderBy(column: string, direction?: OrderDirection): SelectQueryNode<State['output'], Schema>;
+    addHaving(condition: string, parameters?: any[]): SelectQueryNode<State['output'], Schema>;
+    setDistinct(): SelectQueryNode<State['output'], Schema>;
+    setWithTotals(): SelectQueryNode<State['output'], Schema>;
 }
 //# sourceMappingURL=query-modifiers.d.ts.map

package/dist/core/features/query-modifiers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query-modifiers.d.ts","sourceRoot":"","sources":["../../../src/core/features/query-modifiers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,qBAAa,qBAAqB,CAChC,MAAM,SAAS,gBAAgB,CAAC,MAAM,CAAC,EACvC,KAAK,SAAS,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,CAAC,CAAC;IAExF,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC;IAExD,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;;;;;;;;;;;;;;;;;;IAQrC,QAAQ,CAAC,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;IAQtB,SAAS,CAAC,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;IAQvB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,GAAE,cAAsB;;;;;;;;;;;;;;;;;;IAQ5D,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,GAAG,EAAE;;;;;;;;;;;;;;;;;;IAY/C,WAAW;;;;;;;;;;;;;;;;;;CAOZ"}
+{"version":3,"file":"query-modifiers.d.ts","sourceRoot":"","sources":["../../../src/core/features/query-modifiers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5E,qBAAa,qBAAqB,CAChC,MAAM,SAAS,gBAAgB,CAAC,MAAM,CAAC,EACvC,KAAK,SAAS,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC,CAAC,CAAC;IAExF,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC;IAExD,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAgBhF,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAexG,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAQjE,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAY1F,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAQlE,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,GAAE,cAAsB,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAQvG,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,GAAG,EAAE,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAiB1F,WAAW,IAAI,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAQvD,aAAa,IAAI,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAO1D"}

package/dist/core/features/query-modifiers.js

@@ -4,48 +4,94 @@ export class QueryModifiersFeature {
         this.builder = builder;
     }
     addGroupBy(columns) {
-        const config = this.builder.getConfig();
+        const query = this.builder.getQueryNode();
+        const existingExpressions = new Set((query.groupBy || []).map(item => item.expression));
+        const groupByItems = (Array.isArray(columns) ? columns.map(String) : [String(columns)])
+            .filter(expression => {
+            if (existingExpressions.has(expression))
+                return false;
+            existingExpressions.add(expression);
+            return true;
+        })
+            .map(expression => ({ kind: 'group-by-item', expression }));
         return {
-            ...config,
-            groupBy: Array.isArray(columns) ? columns.map(String) : [String(columns)]
+            ...query,
+            groupBy: [...(query.groupBy || []), ...groupByItems]
+        };
+    }
+    addArrayJoin(type, expression) {
+        const query = this.builder.getQueryNode();
+        return {
+            ...query,
+            arrayJoins: [
+                ...(query.arrayJoins || []),
+                {
+                    kind: 'array-join',
+                    type,
+                    expression,
+                },
+            ],
         };
     }
     addLimit(count) {
-        const config = this.builder.getConfig();
+        const query = this.builder.getQueryNode();
         return {
-            ...config,
+            ...query,
             limit: count
         };
     }
+    addLimitBy(limit, by) {
+        const query = this.builder.getQueryNode();
+        return {
+            ...query,
+            limitBy: {
+                kind: 'limit-by',
+                limit,
+                by: Array.isArray(by) ? by.map(String) : [String(by)],
+            },
+        };
+    }
     addOffset(count) {
-        const config = this.builder.getConfig();
+        const query = this.builder.getQueryNode();
         return {
-            ...config,
+            ...query,
             offset: count
         };
     }
     addOrderBy(column, direction = 'ASC') {
-        const config = this.builder.getConfig();
+        const query = this.builder.getQueryNode();
         return {
-            ...config,
-            orderBy: [...(config.orderBy || []), { column, direction }]
+            ...query,
+            orderBy: [...(query.orderBy || []), { kind: 'order-by-item', column, direction }]
         };
     }
     addHaving(condition, parameters) {
-        const config = this.builder.getConfig();
-        const having = [...(config.having || []), condition];
-        const newParams = parameters ? [...(config.parameters || []), ...parameters] : config.parameters;
+        const query = this.builder.getQueryNode();
+        const having = [
+            ...(query.having || []),
+            {
+                kind: 'having',
+                expression: condition,
+                parameters: parameters?.map(value => ({ kind: 'value', value })),
+            }
+        ];
         return {
-            ...config,
-            having,
-            parameters: newParams
+            ...query,
+            having
         };
     }
     setDistinct() {
-        const config = this.builder.getConfig();
+        const query = this.builder.getQueryNode();
         return {
-            ...config,
+            ...query,
             distinct: true
         };
     }
+    setWithTotals() {
+        const query = this.builder.getQueryNode();
+        return {
+            ...query,
+            withTotals: true,
+        };
+    }
 }

package/dist/core/formatters/sql-formatter.d.ts

@@ -1,9 +1,20 @@
-import { QueryConfig } from '../../types/index.js';
+import { type CompiledQuery, type ExprNode, type SelectQueryNode, type SourceNode } from '../../types/index.js';
 export declare class SQLFormatter {
-    formatSelect(config: QueryConfig<any, any>): string;
-    formatGroupBy(config: QueryConfig<any, any>): string;
-    formatWhere(config: QueryConfig<any, any>): string;
+    formatSelect(query: SelectQueryNode<any, any>): string;
+    formatGroupBy(query: SelectQueryNode<any, any>): string;
+    formatArrayJoins(query: SelectQueryNode<any, any>): string;
+    formatPrewhere(query: SelectQueryNode<any, any>): string;
+    formatWhere(query: SelectQueryNode<any, any>): string;
+    formatFrom(source?: SourceNode): string;
+    compileExpr(expr?: ExprNode, nested?: boolean): CompiledQuery;
+    private compileCondition;
+    compileHaving(query: SelectQueryNode<any, any>): CompiledQuery;
     private getSqlOperator;
-    formatJoins(config: QueryConfig<any, any>): string;
+    formatJoins(query: SelectQueryNode<any, any>): string;
+    formatCtes(query: SelectQueryNode<any, any>): string;
+    formatOrderBy(query: SelectQueryNode<any, any>): string;
+    formatLimitBy(query: SelectQueryNode<any, any>): string;
+    private combineCompiled;
+    private combineCompiledWithSeparator;
 }
 //# sourceMappingURL=sql-formatter.d.ts.map

package/dist/core/formatters/sql-formatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sql-formatter.d.ts","sourceRoot":"","sources":["../../../src/core/formatters/sql-formatter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,sBAAsB,CAAC;AAEnE,qBAAa,YAAY;IACvB,YAAY,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IAMnD,aAAa,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IASpD,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IAoGlD,OAAO,CAAC,cAAc;IActB,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;CAUnD"}
+{"version":3,"file":"sql-formatter.d.ts","sourceRoot":"","sources":["../../../src/core/formatters/sql-formatter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,aAAa,EAAE,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAkB,MAAM,sBAAsB,CAAC;AAEhJ,qBAAa,YAAY;IACvB,YAAY,CAAC,KAAK,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IAMtD,aAAa,CAAC,KAAK,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IAMvD,gBAAgB,CAAC,KAAK,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IAO1D,cAAc,CAAC,KAAK,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IAIxD,WAAW,CAAC,KAAK,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IAIrD,UAAU,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,MAAM;IAUvC,WAAW,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,MAAM,UAAQ,GAAG,aAAa;IAmD3D,OAAO,CAAC,gBAAgB;IAuFxB,aAAa,CAAC,KAAK,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,aAAa;IAY9D,OAAO,CAAC,cAAc;IActB,WAAW,CAAC,KAAK,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IAcrD,UAAU,CAAC,KAAK,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IAKpD,aAAa,CAAC,KAAK,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IAOvD,aAAa,CAAC,KAAK,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,MAAM;IAKvD,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,4BAA4B;CAMrC"}

package/dist/core/formatters/sql-formatter.js

@@ -1,109 +1,181 @@
 export class SQLFormatter {
-    formatSelect(config) {
-        const distinctClause = config.distinct ? 'DISTINCT ' : '';
-        if (!config.select?.length)
+    formatSelect(query) {
+        const distinctClause = query.distinct ? 'DISTINCT ' : '';
+        if (!query.select?.length)
             return distinctClause + '*';
-        return distinctClause + config.select.join(', ');
+        return distinctClause + query.select.map(item => item.selection).join(', ');
     }
-    formatGroupBy(config) {
-        const groupBy = config.groupBy;
+    formatGroupBy(query) {
+        const groupBy = query.groupBy;
         if (!groupBy?.length)
             return '';
-        if (Array.isArray(groupBy)) {
-            return groupBy.join(', ');
-        }
-        return String(groupBy);
+        return groupBy.map(item => item.expression).join(', ');
     }
-    formatWhere(config) {
-        if (!config.where?.length)
+    formatArrayJoins(query) {
+        if (!query.arrayJoins?.length)
             return '';
-        let afterGroupStart = false; // Track whether we're immediately after a group-start
-        // First pass - generate the SQL fragments for each condition
-        const fragments = config.where.map((condition, index) => {
-            // Handle expression predicates
-            if (condition.type === 'expression') {
-                const prefix = index === 0 || afterGroupStart ? '' : ` ${condition.conjunction} `;
-                afterGroupStart = false;
-                return `${prefix}${condition.expression}`.trim();
-            }
-            // Handle special group markers
-            if (condition.type === 'group-start') {
-                const prefix = index === 0 ? '' : ` ${condition.conjunction} `;
-                afterGroupStart = true; // Mark that the next condition follows a group-start
-                return `${prefix}(`.trim();
-            }
-            if (condition.type === 'group-end') {
-                afterGroupStart = false; // Reset the flag after group-end
-                return ')';
-            }
-            // Normal conditions
-            const { column, operator, value, conjunction } = condition;
-            // Don't add conjunction if it's the first condition or right after a group-start
-            const prefix = index === 0 || afterGroupStart ? '' : ` ${conjunction} `;
-            // Reset the afterGroupStart flag
-            afterGroupStart = false;
-            // Handle IN operators
-            if (operator === 'in' || operator === 'notIn') {
-                if (!Array.isArray(value)) {
-                    throw new Error(`Expected an array for ${operator} operator, but got ${typeof value}`);
+        return query.arrayJoins
+            .map(item => `${item.type} JOIN ${item.expression}`)
+            .join(' ');
+    }
+    formatPrewhere(query) {
+        return this.compileExpr(query.prewhere).query;
+    }
+    formatWhere(query) {
+        return this.compileExpr(query.where).query;
+    }
+    formatFrom(source) {
+        if (!source)
+            return '';
+        switch (source.kind) {
+            case 'table':
+                return `${source.name}${source.final ? ' FINAL' : ''}`;
+            default:
+                throw new Error(`Unsupported source kind: ${String(source.kind)}`);
+        }
+    }
+    compileExpr(expr, nested = false) {
+        if (!expr)
+            return { query: '', parameters: [] };
+        switch (expr.kind) {
+            case 'raw':
+                return {
+                    query: expr.expression,
+                    parameters: expr.parameters.map(parameter => parameter.value),
+                };
+            case 'group':
+                if (!expr.expression) {
+                    return { query: '', parameters: [] };
                 }
-                if (value.length === 0) {
-                    return `${prefix}1 = 0`;
+                const compiledGroup = this.compileExpr(expr.expression);
+                if (!compiledGroup.query) {
+                    return { query: '', parameters: [] };
                 }
-                const placeholders = value.map(() => '?').join(', ');
-                return `${prefix}${column} ${operator === 'in' ? 'IN' : 'NOT IN'} (${placeholders})`.trim();
+                return {
+                    query: `(${compiledGroup.query})`,
+                    parameters: compiledGroup.parameters,
+                };
+            case 'sequence':
+                return this.combineCompiled(expr.items
+                    .map((item, index) => {
+                    const rendered = this.compileExpr(item.expression, true);
+                    return {
+                        query: index === 0 ? rendered.query : ` ${item.conjunction} ${rendered.query}`,
+                        parameters: rendered.parameters,
+                    };
+                })
+                    .filter(part => part.query.length > 0));
+            case 'logical': {
+                const rendered = expr.conditions
+                    .map(condition => this.compileExpr(condition, true))
+                    .filter(part => part.query.length > 0);
+                if (rendered.length === 0)
+                    return { query: '', parameters: [] };
+                const combined = this.combineCompiledWithSeparator(rendered, ` ${expr.operator} `);
+                return {
+                    query: nested ? `(${combined.query})` : combined.query,
+                    parameters: combined.parameters,
+                };
             }
-            // Handle GLOBAL IN operators
-            else if (operator === 'globalIn' || operator === 'globalNotIn') {
-                if (!Array.isArray(value)) {
-                    throw new Error(`Expected an array for ${operator} operator, but got ${typeof value}`);
-                }
-                if (value.length === 0) {
-                    return `${prefix}1 = 0`;
-                }
-                const placeholders = value.map(() => '?').join(', ');
-                return `${prefix}${column} ${operator === 'globalIn' ? 'GLOBAL IN' : 'GLOBAL NOT IN'} (${placeholders})`.trim();
+            case 'condition':
+                return this.compileCondition(expr);
+            default:
+                throw new Error(`Unsupported expression kind: ${String(expr.kind)}`);
+        }
+    }
+    compileCondition({ column, operator, value }) {
+        if (operator === 'isNull' || operator === 'isNotNull') {
+            return {
+                query: `${column} IS ${operator === 'isNull' ? '' : 'NOT '}NULL`.trim(),
+                parameters: [],
+            };
+        }
+        if (operator === 'in' || operator === 'notIn') {
+            if (!Array.isArray(value)) {
+                throw new Error(`Expected an array for ${operator} operator, but got ${typeof value}`);
             }
-            // Handle subquery IN operators
-            else if (operator === 'inSubquery' || operator === 'globalInSubquery') {
-                if (typeof value !== 'string') {
-                    throw new Error(`Expected a string (subquery) for ${operator} operator, but got ${typeof value}`);
-                }
-                return `${prefix}${column} ${operator === 'inSubquery' ? 'IN' : 'GLOBAL IN'} (${value})`.trim();
+            if (value.length === 0) {
+                return { query: operator === 'in' ? '1 = 0' : '1 = 1', parameters: [] };
             }
-            // Handle table reference IN operators
-            else if (operator === 'inTable' || operator === 'globalInTable') {
-                if (typeof value !== 'string') {
-                    throw new Error(`Expected a string (table name) for ${operator} operator, but got ${typeof value}`);
-                }
-                return `${prefix}${column} ${operator === 'inTable' ? 'IN' : 'GLOBAL IN'} ${value}`.trim();
+            return {
+                query: `${column} ${operator === 'in' ? 'IN' : 'NOT IN'} (${value.map(() => '?').join(', ')})`,
+                parameters: value.map(item => item.value),
+            };
+        }
+        if (operator === 'globalIn' || operator === 'globalNotIn') {
+            if (!Array.isArray(value)) {
+                throw new Error(`Expected an array for ${operator} operator, but got ${typeof value}`);
             }
-            // Handle tuple IN operators
-            else if (operator === 'inTuple' || operator === 'globalInTuple') {
-                if (!Array.isArray(value)) {
-                    throw new Error(`Expected an array of tuples for ${operator} operator, but got ${typeof value}`);
-                }
-                if (value.length === 0) {
-                    return `${prefix}1 = 0`;
-                }
-                const placeholders = value.map(() => '(?, ?)').join(', ');
-                return `${prefix}${column} ${operator === 'inTuple' ? 'IN' : 'GLOBAL IN'} (${placeholders})`.trim();
+            if (value.length === 0) {
+                return { query: operator === 'globalIn' ? '1 = 0' : '1 = 1', parameters: [] };
+            }
+            return {
+                query: `${column} ${operator === 'globalIn' ? 'GLOBAL IN' : 'GLOBAL NOT IN'} (${value.map(() => '?').join(', ')})`,
+                parameters: value.map(item => item.value),
+            };
+        }
+        if (operator === 'inSubquery' || operator === 'globalInSubquery') {
+            if (typeof value !== 'string') {
+                throw new Error(`Expected a string (subquery) for ${operator} operator, but got ${typeof value}`);
+            }
+            return {
+                query: `${column} ${operator === 'inSubquery' ? 'IN' : 'GLOBAL IN'} (${value})`,
+                parameters: [],
+            };
+        }
+        if (operator === 'inTable' || operator === 'globalInTable') {
+            if (typeof value !== 'string') {
+                throw new Error(`Expected a string (table name) for ${operator} operator, but got ${typeof value}`);
             }
-            else if (operator === 'between') {
-                return `${prefix}${column} BETWEEN ? AND ?`.trim();
+            return {
+                query: `${column} ${operator === 'inTable' ? 'IN' : 'GLOBAL IN'} ${value}`,
+                parameters: [],
+            };
+        }
+        if (operator === 'inTuple' || operator === 'globalInTuple') {
+            if (!Array.isArray(value)) {
+                throw new Error(`Expected an array of tuples for ${operator} operator, but got ${typeof value}`);
             }
-            else if (operator === 'like') {
-                return `${prefix}${column} LIKE ?`.trim();
+            if (value.length === 0) {
+                return { query: '1 = 0', parameters: [] };
             }
-            else {
-                return `${prefix}${column} ${this.getSqlOperator(operator)} ?`.trim();
+            const tupleWidth = value[0].length;
+            if (tupleWidth === 0) {
+                throw new Error(`Expected non-empty tuples for ${operator} operator`);
             }
-        });
-        // Join fragments and then remove extra spaces around parentheses
-        let result = fragments.join(' ');
-        // Replace "( " with "(" and " )" with ")"
-        result = result.replace(/\(\s+/g, '(').replace(/\s+\)/g, ')');
-        return result;
+            const tuplePlaceholder = `(${Array.from({ length: tupleWidth }, () => '?').join(', ')})`;
+            return {
+                query: `${column} ${operator === 'inTuple' ? 'IN' : 'GLOBAL IN'} (${value.map(() => tuplePlaceholder).join(', ')})`,
+                parameters: value.flatMap(tuple => tuple.map(item => item.value)),
+            };
+        }
+        if (operator === 'between') {
+            const range = value;
+            return {
+                query: `${column} BETWEEN ? AND ?`,
+                parameters: [range[0].value, range[1].value],
+            };
+        }
+        if (operator === 'like') {
+            const parameter = value;
+            return {
+                query: `${column} LIKE ?`,
+                parameters: [parameter.value],
+            };
+        }
+        const parameter = value;
+        return {
+            query: `${column} ${this.getSqlOperator(operator)} ?`,
+            parameters: [parameter.value],
+        };
+    }
+    compileHaving(query) {
+        if (!query.having?.length)
+            return { query: '', parameters: [] };
+        return this.combineCompiledWithSeparator(query.having.map(item => ({
+            query: item.expression,
+            parameters: item.parameters?.map(parameter => parameter.value) || [],
+        })), ' AND ');
     }
     getSqlOperator(operator) {
         switch (operator) {
@@ -118,14 +190,46 @@ export class SQLFormatter {
                 throw new Error(`Unsupported operator: ${operator}`);
         }
     }
-    formatJoins(config) {
-        if (!config.joins?.length)
+    formatJoins(query) {
+        if (!query.joins?.length)
             return '';
-        return config.joins.map(join => {
+        return query.joins.map(join => {
             const tableClause = join.alias
                 ? `${join.table} AS ${join.alias}`
                 : join.table;
-            return `${join.type} JOIN ${tableClause} ON ${join.leftColumn} = ${join.rightColumn}`;
+            const leftColumn = join.leftSource && !join.leftColumn.includes('.')
+                ? `${join.leftSource}.${join.leftColumn}`
+                : join.leftColumn;
+            return `${join.type} JOIN ${tableClause} ON ${leftColumn} = ${join.rightColumn}`;
         }).join(' ');
     }
+    formatCtes(query) {
+        if (!query.ctes?.length)
+            return '';
+        return query.ctes.map(item => item.expression).join(', ');
+    }
+    formatOrderBy(query) {
+        if (!query.orderBy?.length)
+            return '';
+        return query.orderBy
+            .map(({ column, direction }) => `${String(column)} ${direction}`.trim())
+            .join(', ');
+    }
+    formatLimitBy(query) {
+        if (!query.limitBy)
+            return '';
+        return `${query.limitBy.limit} BY ${query.limitBy.by.join(', ')}`;
+    }
+    combineCompiled(parts) {
+        return {
+            query: parts.map(part => part.query).join(''),
+            parameters: parts.flatMap(part => part.parameters),
+        };
+    }
+    combineCompiledWithSeparator(parts, separator) {
+        return {
+            query: parts.map(part => part.query).join(separator),
+            parameters: parts.flatMap(part => part.parameters),
+        };
+    }
 }