@hypequery/clickhouse 1.6.2 → 2.0.0

package/dist/core/query-builder.js

@@ -9,8 +9,22 @@ import { QueryModifiersFeature } from './features/query-modifiers.js';
 import { FilterValidator } from './validators/filter-validator.js';
 import { createPredicateBuilder, } from './utils/predicate-builder.js';
 import { CrossFilteringFeature } from './features/cross-filtering.js';
+import { cloneSelectQueryNode, createSelectQueryNode, transformSelectQueryNode, } from './query-node.js';
 import { executeWithCache } from './cache/cache-manager.js';
 import { mergeCacheOptionsPartial, initializeCacheRuntime } from './cache/utils.js';
+import { normalizeFilterApplication } from './utils/filter-application.js';
+import { toLegacyQueryConfig } from './utils/query-config-compat.js';
+import { applyRelationPath, resolveRelationPath } from './utils/relation-application.js';
+const ADVANCED_IN_OPERATORS = new Set([
+    'globalIn',
+    'globalNotIn',
+    'inSubquery',
+    'globalInSubquery',
+    'inTable',
+    'globalInTable',
+    'inTuple',
+    'globalInTuple',
+]);
 /**
  * Type guard to check if a config is a client-based configuration.
  */
@@ -23,7 +37,7 @@ export function isClientConfig(config) {
  */
 export class QueryBuilder {
     static relationships;
-    config = {};
+    query;
     tableName;
     state;
     aggregations;
@@ -37,8 +51,15 @@ export class QueryBuilder {
     adapter;
     dialect;
     cacheOptions;
+    queryTransforms = [];
     constructor(tableName, state, runtime, adapter, dialect) {
         this.tableName = tableName;
+        this.query = createSelectQueryNode({
+            from: {
+                kind: 'table',
+                name: tableName,
+            },
+        });
         this.state = state;
         this.runtime = runtime;
         this.adapter = adapter;
@@ -51,31 +72,98 @@ export class QueryBuilder {
         this.modifiers = new QueryModifiersFeature(this);
         this.crossFiltering = new CrossFilteringFeature(this);
     }
-    fork(state, config) {
+    fork(state, query) {
+        return this.transition(state, query);
+    }
+    transition(state, query) {
         const builder = new QueryBuilder(this.tableName, state, this.runtime, this.adapter, this.dialect);
-        builder.config = { ...config };
-        builder.cacheOptions = this.cacheOptions;
+        builder.query = cloneSelectQueryNode(query);
+        builder.cacheOptions = this.cacheOptions ? { ...this.cacheOptions } : undefined;
+        builder.queryTransforms = [...this.queryTransforms];
+        return builder;
+    }
+    cloneMutable() {
+        return this.fork(this.state, this.query);
+    }
+    assignQuery(builder, query) {
+        builder.query = cloneSelectQueryNode(query);
         return builder;
     }
+    updateQuery(updater) {
+        return this.assignQuery(this.cloneMutable(), updater(this.query));
+    }
+    withAliasesState(aliases) {
+        return {
+            ...this.state,
+            aliases,
+        };
+    }
+    buildSelectState(output) {
+        return {
+            ...this.state,
+            output,
+        };
+    }
+    buildSelectQuery(selections) {
+        return {
+            ...this.query,
+            select: selections.map(selection => ({ kind: 'selection', selection })),
+            orderBy: this.query.orderBy?.map(({ column, direction }) => ({
+                kind: 'order-by-item',
+                column: String(column),
+                direction,
+            })),
+        };
+    }
+    createDetachedBuilder() {
+        const builder = new QueryBuilder(this.tableName, this.state, this.runtime, this.adapter, this.dialect);
+        builder.query = createSelectQueryNode();
+        builder.cacheOptions = this.cacheOptions ? { ...this.cacheOptions } : undefined;
+        builder.queryTransforms = [...this.queryTransforms];
+        return builder;
+    }
+    runDraftCallback(seed, callback) {
+        let current = seed;
+        // Group callbacks expect fluent chaining, so the draft keeps rebinding
+        // method calls to the latest immutable builder instance produced so far.
+        const draft = new Proxy(seed, {
+            get: (_target, prop, receiver) => {
+                const value = Reflect.get(current, prop, receiver);
+                if (typeof value !== 'function') {
+                    return value;
+                }
+                return (...args) => {
+                    const result = value.apply(current, args);
+                    if (result instanceof QueryBuilder) {
+                        current = result;
+                        return draft;
+                    }
+                    return result;
+                };
+            },
+        });
+        callback(draft);
+        return current;
+    }
     debug() {
         console.log('Current Type:', {
             state: this.state,
-            config: this.config
+            query: this.query
         });
         return this;
     }
     cache(options) {
+        const next = this.cloneMutable();
         if (options === false) {
-            this.cacheOptions = { mode: 'no-store', ttlMs: 0, staleTtlMs: 0, cacheTimeMs: 0 };
-            return this;
+            next.cacheOptions = { mode: 'no-store', ttlMs: 0, staleTtlMs: 0, cacheTimeMs: 0 };
+            return next;
         }
-        this.cacheOptions = mergeCacheOptionsPartial(this.cacheOptions, options);
-        return this;
+        next.cacheOptions = mergeCacheOptionsPartial(next.cacheOptions, options);
+        return next;
     }
     // --- Analytics Helper: Add a CTE.
     withCTE(alias, subquery) {
-        this.config = this.analytics.addCTE(alias, subquery);
-        return this;
+        return this.updateQuery(() => this.analytics.addCTE(alias, subquery));
     }
     // --- Analytics Helper: Add a scalar WITH alias.
     withScalar(alias, expressionBuilder) {
@@ -84,17 +172,15 @@ export class QueryBuilder {
         }
         const expression = expressionBuilder(createPredicateBuilder());
         const nextConfig = this.analytics.addScalar(alias, expression);
+        const nextScalars = {
+            ...this.state.scalars,
+            [alias]: undefined,
+        };
         const nextState = {
             ...this.state,
-            scalars: {
-                ...this.state.scalars,
-                [alias]: undefined,
-            },
+            scalars: nextScalars,
         };
-        const builder = new QueryBuilder(this.tableName, nextState, this.runtime, this.adapter, this.dialect);
-        builder.config = { ...nextConfig };
-        builder.cacheOptions = this.cacheOptions;
-        return builder;
+        return this.transition(nextState, nextConfig);
     }
     /**
    * Groups results by a time interval using a specified ClickHouse function.
@@ -109,42 +195,35 @@ export class QueryBuilder {
    * @returns The current QueryBuilder instance.
    */
     groupByTimeInterval(column, interval, method = 'toStartOfInterval') {
-        this.config = this.analytics.addTimeInterval(String(column), interval, method, this.dialect);
-        return this;
+        return this.updateQuery(() => this.analytics.addTimeInterval(String(column), interval, method, this.dialect));
     }
     // --- Analytics Helper: Add a raw SQL fragment.
     raw(sql) {
-        // Use raw() to inject SQL that isn't supported by the builder.
-        // Use with caution.
-        this.config.having = this.config.having || [];
-        this.config.having.push(sql);
-        return this;
+        return this.updateQuery(query => ({
+            ...query,
+            having: [...(query.having || []), { kind: 'having', expression: sql }],
+        }));
     }
     // --- Analytics Helper: Add query settings.
     settings(opts) {
-        this.config = this.analytics.addSettings(opts);
-        return this;
+        return this.updateQuery(() => this.analytics.addSettings(opts));
+    }
+    final() {
+        return this.updateQuery(query => ({
+            ...query,
+            from: {
+                kind: 'table',
+                name: this.tableName,
+                final: true,
+            },
+        }));
     }
     applyCrossFilters(crossFilter) {
-        const normalized = crossFilter;
-        this.config = this.crossFiltering.applyCrossFilters(normalized);
-        return this;
+        return this.crossFiltering.applyCrossFilters(crossFilter);
     }
     select(columnsOrAsterisk) {
         if (columnsOrAsterisk === '*') {
-            const nextState = {
-                ...this.state,
-                output: {}
-            };
-            const nextConfig = {
-                ...this.config,
-                select: ['*'],
-                orderBy: this.config.orderBy?.map(({ column, direction }) => ({
-                    column: String(column),
-                    direction
-                }))
-            };
-            return this.fork(nextState, nextConfig);
+            return this.fork(this.buildSelectState({}), this.buildSelectQuery(['*']));
         }
         const columns = columnsOrAsterisk;
         const processedColumns = columns.map(col => {
@@ -153,19 +232,7 @@ export class QueryBuilder {
             }
             return String(col);
         });
-        const nextState = {
-            ...this.state,
-            output: {}
-        };
-        const nextConfig = {
-            ...this.config,
-            select: processedColumns,
-            orderBy: this.config.orderBy?.map(({ column, direction }) => ({
-                column: String(column),
-                direction
-            }))
-        };
-        return this.fork(nextState, nextConfig);
+        return this.fork(this.buildSelectState({}), this.buildSelectQuery(processedColumns));
     }
     selectConst(...columns) {
         return this.select(columns);
@@ -188,10 +255,7 @@ export class QueryBuilder {
     applyAggregation(column, alias, suffix, updater) {
         const columnName = String(column);
         const finalAlias = (alias || `${columnName}_${suffix}`);
-        const nextState = {
-            ...this.state,
-            output: {}
-        };
+        const nextState = this.buildSelectState({});
         const nextConfig = updater(columnName, finalAlias);
         return this.fork(nextState, nextConfig);
     }
@@ -256,11 +320,7 @@ export class QueryBuilder {
             return;
         }
         // Skip validation for advanced IN operators - they handle their own validation
-        const advancedInOperators = [
-            'globalIn', 'globalNotIn', 'inSubquery', 'globalInSubquery',
-            'inTable', 'globalInTable', 'inTuple', 'globalInTuple'
-        ];
-        if (advancedInOperators.includes(operator)) {
+        if (ADVANCED_IN_OPERATORS.has(operator) || operator === 'isNull' || operator === 'isNotNull') {
             return;
         }
         const columnName = String(column);
@@ -270,46 +330,25 @@ export class QueryBuilder {
         const columnType = baseColumns[columnName];
         FilterValidator.validateFilterCondition({ column: columnName, operator, value }, columnType);
     }
-    where(columnOrColumns, operator, value) {
-        if (typeof columnOrColumns === 'function') {
-            const expression = columnOrColumns(createPredicateBuilder());
-            this.config = this.filtering.addExpressionCondition('AND', expression);
-            return this;
-        }
-        if (operator === undefined) {
-            throw new Error('Operator is required when specifying a column for where()');
+    applyFilter(clause, conjunction, columnOrColumns, operator, value) {
+        const normalized = normalizeFilterApplication(clause, conjunction, columnOrColumns, operator, value, builder => builder(createPredicateBuilder()));
+        if (normalized.kind === 'expression') {
+            return this.updateQuery(() => this.filtering.addExpressionCondition(clause, conjunction, normalized.expression));
         }
-        // Handle tuple operations
-        if (Array.isArray(columnOrColumns) && (operator === 'inTuple' || operator === 'globalInTuple')) {
-            const columns = columnOrColumns;
-            this.validateFilterValue(columns, operator, value);
-            this.config = this.filtering.addCondition('AND', columns.map(String), operator, value);
-            return this;
-        }
-        const column = columnOrColumns;
-        this.validateFilterValue(column, operator, value);
-        this.config = this.filtering.addCondition('AND', String(column), operator, value);
-        return this;
+        this.validateFilterValue(normalized.validationTarget, normalized.operator, normalized.value);
+        return this.updateQuery(() => this.filtering.addCondition(clause, conjunction, normalized.column, normalized.operator, normalized.value));
+    }
+    where(columnOrColumns, operator, value) {
+        return this.applyFilter('where', 'AND', columnOrColumns, operator, value);
     }
     orWhere(columnOrColumns, operator, value) {
-        if (typeof columnOrColumns === 'function') {
-            const expression = columnOrColumns(createPredicateBuilder());
-            this.config = this.filtering.addExpressionCondition('OR', expression);
-            return this;
-        }
-        if (operator === undefined) {
-            throw new Error('Operator is required when specifying a column for orWhere()');
-        }
-        if (Array.isArray(columnOrColumns) && (operator === 'inTuple' || operator === 'globalInTuple')) {
-            const columns = columnOrColumns;
-            this.validateFilterValue(columns, operator, value);
-            this.config = this.filtering.addCondition('OR', columns.map(String), operator, value);
-            return this;
-        }
-        const column = columnOrColumns;
-        this.validateFilterValue(column, operator, value);
-        this.config = this.filtering.addCondition('OR', String(column), operator, value);
-        return this;
+        return this.applyFilter('where', 'OR', columnOrColumns, operator, value);
+    }
+    prewhere(columnOrColumns, operator, value) {
+        return this.applyFilter('prewhere', 'AND', columnOrColumns, operator, value);
+    }
+    orPrewhere(columnOrColumns, operator, value) {
+        return this.applyFilter('prewhere', 'OR', columnOrColumns, operator, value);
     }
     /**
      * Creates a parenthesized group of WHERE conditions joined with AND/OR operators.
@@ -323,10 +362,8 @@ export class QueryBuilder {
      * ```
      */
     whereGroup(callback) {
-        this.config = this.filtering.startWhereGroup();
-        callback(this);
-        this.config = this.filtering.endWhereGroup();
-        return this;
+        const groupBuilder = this.runDraftCallback(this.createDetachedBuilder(), callback);
+        return this.updateQuery(() => this.filtering.addGroup('where', 'AND', groupBuilder.getQueryNode().where));
     }
     /**
      * Creates a parenthesized group of WHERE conditions joined with OR operator.
@@ -340,10 +377,8 @@ export class QueryBuilder {
      * ```
      */
     orWhereGroup(callback) {
-        this.config = this.filtering.startOrWhereGroup();
-        callback(this);
-        this.config = this.filtering.endWhereGroup();
-        return this;
+        const groupBuilder = this.runDraftCallback(this.createDetachedBuilder(), callback);
+        return this.updateQuery(() => this.filtering.addGroup('where', 'OR', groupBuilder.getQueryNode().where));
     }
     /**
      * Adds a GROUP BY clause.
@@ -356,16 +391,23 @@ export class QueryBuilder {
      */
     groupBy(columns) {
         const normalized = Array.isArray(columns) ? columns.map(String) : String(columns);
-        this.config = this.modifiers.addGroupBy(normalized);
-        return this;
+        return this.updateQuery(() => this.modifiers.addGroupBy(normalized));
+    }
+    arrayJoin(column) {
+        return this.updateQuery(() => this.modifiers.addArrayJoin('ARRAY', String(column)));
+    }
+    leftArrayJoin(column) {
+        return this.updateQuery(() => this.modifiers.addArrayJoin('LEFT ARRAY', String(column)));
     }
     limit(count) {
-        this.config = this.modifiers.addLimit(count);
-        return this;
+        return this.updateQuery(() => this.modifiers.addLimit(count));
+    }
+    limitBy(count, by) {
+        const normalized = Array.isArray(by) ? by.map(String) : String(by);
+        return this.updateQuery(() => this.modifiers.addLimitBy(count, normalized));
     }
     offset(count) {
-        this.config = this.modifiers.addOffset(count);
-        return this;
+        return this.updateQuery(() => this.modifiers.addOffset(count));
     }
     /**
      * Adds an ORDER BY clause.
@@ -378,8 +420,7 @@ export class QueryBuilder {
      * ```
      */
     orderBy(column, direction = 'ASC') {
-        this.config = this.modifiers.addOrderBy(String(column), direction);
-        return this;
+        return this.updateQuery(() => this.modifiers.addOrderBy(String(column), direction));
     }
     /**
      * Adds a HAVING clause for filtering grouped results.
@@ -391,12 +432,31 @@ export class QueryBuilder {
      * ```
      */
     having(condition, parameters) {
-        this.config = this.modifiers.addHaving(condition, parameters);
-        return this;
+        return this.updateQuery(() => this.modifiers.addHaving(condition, parameters));
     }
     distinct() {
-        this.config = this.modifiers.setDistinct();
-        return this;
+        return this.updateQuery(() => this.modifiers.setDistinct());
+    }
+    withTotals() {
+        return this.updateQuery(() => this.modifiers.setWithTotals());
+    }
+    whereNull(column) {
+        return this.updateQuery(() => this.filtering.addCondition('where', 'AND', String(column), 'isNull', null));
+    }
+    whereNotNull(column) {
+        return this.updateQuery(() => this.filtering.addCondition('where', 'AND', String(column), 'isNotNull', null));
+    }
+    orWhereNull(column) {
+        return this.updateQuery(() => this.filtering.addCondition('where', 'OR', String(column), 'isNull', null));
+    }
+    orWhereNotNull(column) {
+        return this.updateQuery(() => this.filtering.addCondition('where', 'OR', String(column), 'isNotNull', null));
+    }
+    prewhereNull(column) {
+        return this.updateQuery(() => this.filtering.addCondition('prewhere', 'AND', String(column), 'isNull', null));
+    }
+    prewhereNotNull(column) {
+        return this.updateQuery(() => this.filtering.addCondition('prewhere', 'AND', String(column), 'isNotNull', null));
     }
     whereBetween(column, [min, max]) {
         if (min === null || max === null) {
@@ -417,46 +477,43 @@ export class QueryBuilder {
         return this.applyJoin('FULL', table, leftColumn, rightColumn, alias);
     }
     applyJoin(type, table, leftColumn, rightColumn, alias) {
-        const nextState = {
-            ...this.state,
-            aliases: alias ? { ...this.state.aliases, [alias]: table } : this.state.aliases
-        };
+        const nextAliases = (alias
+            ? { ...this.state.aliases, [alias]: table }
+            : this.state.aliases);
+        const nextState = this.withAliasesState(nextAliases);
         const nextConfig = this.joins.addJoin(type, table, String(leftColumn), rightColumn, alias);
-        return this.fork(nextState, nextConfig);
+        return this.transition(nextState, nextConfig);
     }
-    // Make config accessible to features
+    /**
+     * @deprecated Prefer `getQueryNode()` for inspection or `toQueryNode()` for the
+     * transformed query tree used during compilation.
+     */
     getConfig() {
-        return this.config;
+        return toLegacyQueryConfig(this.getQueryNode());
+    }
+    toQueryNode() {
+        return transformSelectQueryNode(this.query, this.queryTransforms);
+    }
+    getQueryNode() {
+        return cloneSelectQueryNode(this.query);
     }
     static setJoinRelationships(relationships) {
         this.relationships = relationships;
     }
-    /**
-     * Apply a predefined join relationship
-     */
-    withRelation(name, options) {
-        const relationships = QueryBuilder.relationships;
-        if (!relationships) {
-            throw new Error('Join relationships have not been initialized. Call QueryBuilder.setJoinRelationships first.');
-        }
-        const path = relationships.get(name);
-        if (!path) {
-            throw new Error(`Join relationship '${name}' not found`);
-        }
-        const applyJoin = (joinPath) => {
+    withRelation(nameOrPath, options) {
+        const next = this.cloneMutable();
+        const { path, label } = resolveRelationPath(nameOrPath, QueryBuilder.relationships);
+        next.query = applyRelationPath(next.query, path, options, (currentQuery, joinPath, relationOptions) => {
+            next.query = currentQuery;
             const type = options?.type || joinPath.type || 'INNER';
-            const alias = options?.alias || joinPath.alias;
+            const alias = relationOptions?.alias || joinPath.alias;
+            const leftColumn = String(joinPath.leftColumn);
+            const leftSource = String(joinPath.from);
             const table = String(joinPath.to);
             const rightColumn = `${table}.${joinPath.rightColumn}`;
-            this.config = this.joins.addJoin(type, table, joinPath.leftColumn, rightColumn, alias);
-        };
-        if (Array.isArray(path)) {
-            path.forEach(applyJoin);
-        }
-        else {
-            applyJoin(path);
-        }
-        return this;
+            return next.joins.addJoin(type, table, leftColumn, rightColumn, alias, leftSource);
+        }, label);
+        return next;
     }
 }
 export function createQueryBuilder(config) {

package/dist/core/query-node.d.ts

@@ -0,0 +1,7 @@
+import type { ExprNode, QueryConfig, SelectQueryNode } from '../types/index.js';
+export declare function cloneExprNode(expr?: ExprNode): ExprNode | undefined;
+export declare function createSelectQueryNode<TOutput, TSchema>(config?: QueryConfig<TOutput, TSchema>): SelectQueryNode<TOutput, TSchema>;
+export declare function cloneSelectQueryNode<TOutput, TSchema>(query: SelectQueryNode<TOutput, TSchema>): SelectQueryNode<TOutput, TSchema>;
+export type QueryNodeTransform<TOutput, TSchema> = (query: SelectQueryNode<TOutput, TSchema>) => SelectQueryNode<TOutput, TSchema>;
+export declare function transformSelectQueryNode<TOutput, TSchema>(query: SelectQueryNode<TOutput, TSchema>, transforms: ReadonlyArray<QueryNodeTransform<TOutput, TSchema>>): SelectQueryNode<TOutput, TSchema>;
+//# sourceMappingURL=query-node.d.ts.map

package/dist/core/query-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-node.d.ts","sourceRoot":"","sources":["../../src/core/query-node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,QAAQ,EACR,WAAW,EACX,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAY3B,wBAAgB,aAAa,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAgCnE;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,EACpD,MAAM,GAAE,WAAW,CAAC,OAAO,EAAE,OAAO,CAAM,GACzC,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,CA+BnC;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EACnD,KAAK,EAAE,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,GACvC,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,CAEnC;AAED,MAAM,MAAM,kBAAkB,CAAC,OAAO,EAAE,OAAO,IAAI,CACjD,KAAK,EAAE,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,KACrC,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;AAEvC,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,EACvD,KAAK,EAAE,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,EACxC,UAAU,EAAE,aAAa,CAAC,kBAAkB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,GAC9D,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,CAKnC"}

package/dist/core/query-node.js

@@ -0,0 +1,80 @@
+function cloneConditionValue(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(item => Array.isArray(item) ? item.map(inner => ({ ...inner })) : { ...item });
+    }
+    return { ...value };
+}
+export function cloneExprNode(expr) {
+    if (!expr)
+        return undefined;
+    switch (expr.kind) {
+        case 'condition':
+            return { ...expr, value: cloneConditionValue(expr.value) };
+        case 'raw':
+            return {
+                ...expr,
+                parameters: expr.parameters.map(parameter => ({ ...parameter })),
+            };
+        case 'group':
+            return {
+                ...expr,
+                expression: cloneExprNode(expr.expression),
+            };
+        case 'logical':
+            return {
+                ...expr,
+                conditions: expr.conditions.map(condition => cloneExprNode(condition)),
+            };
+        case 'sequence':
+            return {
+                ...expr,
+                items: expr.items.map(item => ({
+                    ...item,
+                    expression: cloneExprNode(item.expression),
+                })),
+            };
+        default:
+            throw new Error(`Unsupported expression kind: ${String(expr.kind)}`);
+    }
+}
+export function createSelectQueryNode(config = {}) {
+    return {
+        kind: 'select-query',
+        from: config.from ? { ...config.from } : undefined,
+        select: config.select ? config.select.map(item => ({ ...item })) : undefined,
+        arrayJoins: config.arrayJoins ? config.arrayJoins.map(item => ({ ...item })) : undefined,
+        prewhere: cloneExprNode(config.prewhere),
+        where: cloneExprNode(config.where),
+        groupBy: config.groupBy ? config.groupBy.map(item => ({ ...item })) : undefined,
+        withTotals: config.withTotals,
+        having: config.having
+            ? config.having.map(item => ({
+                ...item,
+                parameters: item.parameters?.map(parameter => ({ ...parameter })),
+            }))
+            : undefined,
+        limitBy: config.limitBy
+            ? {
+                ...config.limitBy,
+                by: [...config.limitBy.by],
+            }
+            : undefined,
+        limit: config.limit,
+        offset: config.offset,
+        distinct: config.distinct,
+        orderBy: config.orderBy ? config.orderBy.map(item => ({ ...item })) : undefined,
+        joins: config.joins ? config.joins.map(item => ({ ...item })) : undefined,
+        ctes: config.ctes ? config.ctes.map(item => ({ ...item })) : undefined,
+        unionQueries: config.unionQueries ? [...config.unionQueries] : undefined,
+        settings: config.settings ? { ...config.settings } : undefined,
+    };
+}
+export function cloneSelectQueryNode(query) {
+    return createSelectQueryNode(query);
+}
+export function transformSelectQueryNode(query, transforms) {
+    return transforms.reduce((current, transform) => transform(current), cloneSelectQueryNode(query));
+}

package/dist/core/tests/integration/setup.d.ts

@@ -27,6 +27,7 @@ export interface TestSchemaType {
         price: number;
         created_at: string;
         is_active: boolean;
+        tags: string[];
     }>;
     users: Array<{
         id: number;

package/dist/core/tests/integration/setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../../src/core/tests/integration/setup.ts"],"names":[],"mappings":"AAgDA,eAAO,MAAM,sBAAsB;;;;;CAAS,CAAC;AAG7C,eAAO,MAAM,wBAAwB;;;;;;EAyBpC,CAAC;AAGF,eAAO,MAAM,2BAA2B,yGAevC,CAAC;AAGF,eAAO,MAAM,iBAAiB,QAAa,OAAO,CAAC,OAAO,CAOzD,CAAC;AAGF,eAAO,MAAM,wBAAwB,QAAa,OAAO,CAAC,OAAO,CAahE,CAAC;AAGF,eAAO,MAAM,kBAAkB,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,OAAO,CAO/E,CAAC;AAGF,eAAO,MAAM,iBAAiB,QAAa,OAAO,CAAC,OAAO,CAQzD,CAAC;AAGF,eAAO,MAAM,wBAAwB,QAAa,OAAO,CAAC,IAAI,CAwC7D,CAAC;AAGF,eAAO,MAAM,iBAAiB,GAC5B,oBAAgB,EAChB,sBAAoB,KACnB,OAAO,CAAC,IAAI,CAad,CAAC;AAGF,eAAO,MAAM,uBAAuB,QAAa,OAAO,CAAC,IAAI,CA0B5D,CAAC;AAGF,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,KAAK,CAAC;QAChB,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,OAAO,CAAC;KACpB,CAAC,CAAC;IACH,KAAK,EAAE,KAAK,CAAC;QACX,EAAE,EAAE,MAAM,CAAC;QACX,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;IACH,MAAM,EAAE,KAAK,CAAC;QACZ,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;CACJ;AAkDD,eAAO,MAAM,SAAS,EAAE,cAAoC,CAAC;AAK7D,eAAO,MAAM,iBAAiB,QAAa,OAAO,CAAC,IAAI,CAkGtD,CAAC"}
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../../src/core/tests/integration/setup.ts"],"names":[],"mappings":"AAgDA,eAAO,MAAM,sBAAsB;;;;;CAAS,CAAC;AAG7C,eAAO,MAAM,wBAAwB;;;;;;EAyBpC,CAAC;AAGF,eAAO,MAAM,2BAA2B,yGAevC,CAAC;AAGF,eAAO,MAAM,iBAAiB,QAAa,OAAO,CAAC,OAAO,CAOzD,CAAC;AAGF,eAAO,MAAM,wBAAwB,QAAa,OAAO,CAAC,OAAO,CAahE,CAAC;AAGF,eAAO,MAAM,kBAAkB,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,OAAO,CAO/E,CAAC;AAGF,eAAO,MAAM,iBAAiB,QAAa,OAAO,CAAC,OAAO,CAQzD,CAAC;AAGF,eAAO,MAAM,wBAAwB,QAAa,OAAO,CAAC,IAAI,CAwC7D,CAAC;AAGF,eAAO,MAAM,iBAAiB,GAC5B,oBAAgB,EAChB,sBAAoB,KACnB,OAAO,CAAC,IAAI,CAad,CAAC;AAGF,eAAO,MAAM,uBAAuB,QAAa,OAAO,CAAC,IAAI,CA0B5D,CAAC;AAGF,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,KAAK,CAAC;QAChB,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,OAAO,CAAC;QACnB,IAAI,EAAE,MAAM,EAAE,CAAC;KAChB,CAAC,CAAC;IACH,KAAK,EAAE,KAAK,CAAC;QACX,EAAE,EAAE,MAAM,CAAC;QACX,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;IACH,MAAM,EAAE,KAAK,CAAC;QACZ,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;CACJ;AAmDD,eAAO,MAAM,SAAS,EAAE,cAAoC,CAAC;AAK7D,eAAO,MAAM,iBAAiB,QAAa,OAAO,CAAC,IAAI,CAmGtD,CAAC"}

package/dist/core/tests/integration/setup.js

@@ -234,7 +234,8 @@ function normalizeTestData() {
         category: row.category,
         price: row.price,
         created_at: normalizeDateValue(row.created_at),
-        is_active: row.is_active
+        is_active: row.is_active,
+        tags: row.tags ?? [],
     }));
     const users = (rawTestData.users ?? []).map(row => ({
         id: row.id,
@@ -285,7 +286,8 @@ export const setupTestDatabase = async () => {
           category String,
           price Float64,
           created_at Date,
-          is_active Boolean
+          is_active Boolean,
+          tags Array(String)
         ) ENGINE = MergeTree()
         ORDER BY id
       `

package/dist/core/types/select-types.d.ts

@@ -18,6 +18,9 @@ export type SelectableItem<State extends AnyBuilderState> = SelectableColumn<Sta
 export type ColumnSelectionKey<P> = P extends `${string}.${infer C}` ? C : P;
 type QualifiedColumnValue<State extends AnyBuilderState, P> = P extends `${infer Table}.${infer Column}` ? ResolveTableSchema<State, Table> extends Record<string, ColumnType> ? Column extends keyof ResolveTableSchema<State, Table> ? ResolveTableSchema<State, Table>[Column] extends ColumnType ? InferColumnType<ResolveTableSchema<State, Table>[Column]> : never : never : never : never;
 export type ColumnSelectionValue<State extends AnyBuilderState, P> = P extends OutputColumnKeys<State> ? State['output'][P] : P extends ScalarColumnKeys<State> ? State['scalars'][P] : P extends BaseColumnKeys<State> ? BaseRow<State>[P] : QualifiedColumnValue<State, P>;
+export type ArraySelectableColumn<State extends AnyBuilderState> = {
+    [P in SelectableColumn<State>]: ColumnSelectionValue<State, P> extends readonly unknown[] | null ? P : never;
+}[SelectableColumn<State>];
 export type ColumnSelectionRecord<State extends AnyBuilderState, K> = {
     [P in Extract<K, SelectableColumn<State>> as ColumnSelectionKey<P>]: ColumnSelectionValue<State, P>;
 };