@ductape/sdk 0.0.4-v51 → 0.0.4-v52

package/dist/database/operators/aggregation-builder.js

@@ -0,0 +1,746 @@
+"use strict";
+/**
+ * Aggregation Builder
+ *
+ * Builds database aggregation queries from the uniform ORM interface.
+ * Translates aggregation options to database-specific SQL or aggregation pipelines.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregationOperators = exports.AggregationBuilder = void 0;
+const enums_1 = require("../types/enums");
+/**
+ * Aggregation builder for translating ORM aggregations to database-specific formats
+ */
+class AggregationBuilder {
+    constructor(databaseType) {
+        this.databaseType = databaseType;
+    }
+    /**
+     * Build an aggregation query
+     * @param options Aggregation options
+     * @returns Built aggregation ready for execution
+     */
+    buildAggregation(options) {
+        switch (this.databaseType) {
+            case enums_1.DatabaseType.POSTGRESQL:
+                return this.buildPostgresAggregation(options);
+            case enums_1.DatabaseType.MYSQL:
+            case enums_1.DatabaseType.MARIADB:
+                return this.buildMySQLAggregation(options);
+            case enums_1.DatabaseType.MONGODB:
+                return this.buildMongoAggregation(options);
+            case enums_1.DatabaseType.DYNAMODB:
+                return this.buildDynamoAggregation(options);
+            case enums_1.DatabaseType.CASSANDRA:
+                return this.buildCassandraAggregation(options);
+            default:
+                throw new Error(`Unsupported database type: ${this.databaseType}`);
+        }
+    }
+    /**
+     * Build a group by aggregation query
+     * @param options Group by options
+     * @returns Built aggregation ready for execution
+     */
+    buildGroupBy(options) {
+        switch (this.databaseType) {
+            case enums_1.DatabaseType.POSTGRESQL:
+                return this.buildPostgresGroupBy(options);
+            case enums_1.DatabaseType.MYSQL:
+            case enums_1.DatabaseType.MARIADB:
+                return this.buildMySQLGroupBy(options);
+            case enums_1.DatabaseType.MONGODB:
+                return this.buildMongoGroupBy(options);
+            case enums_1.DatabaseType.DYNAMODB:
+                return this.buildDynamoGroupBy(options);
+            case enums_1.DatabaseType.CASSANDRA:
+                return this.buildCassandraGroupBy(options);
+            default:
+                throw new Error(`Unsupported database type: ${this.databaseType}`);
+        }
+    }
+    // ==================== POSTGRESQL AGGREGATION ====================
+    buildPostgresAggregation(options) {
+        const params = [];
+        let paramIndex = 1;
+        // Build SELECT clause with aggregations
+        const selectClauses = this.buildAggregationSelectClauses(options.operations, 'postgresql');
+        let sql = `SELECT ${selectClauses.join(', ')} FROM ${this.escapeIdentifier(options.table, 'postgresql')}`;
+        // WHERE clause
+        if (options.where) {
+            const whereResult = this.buildWhereClause(options.where, 'postgresql', paramIndex);
+            sql += ` WHERE ${whereResult.clause}`;
+            params.push(...whereResult.params);
+            paramIndex += whereResult.params.length;
+        }
+        return {
+            options,
+            sql,
+            params,
+        };
+    }
+    buildPostgresGroupBy(options) {
+        const params = [];
+        let paramIndex = 1;
+        // Build SELECT clause with group columns and aggregations
+        const groupColumns = options.groupBy.map(col => this.escapeIdentifier(col, 'postgresql'));
+        const aggClauses = this.buildAggregationSelectClauses(options.operations, 'postgresql');
+        let sql = `SELECT ${[...groupColumns, ...aggClauses].join(', ')} FROM ${this.escapeIdentifier(options.table, 'postgresql')}`;
+        // WHERE clause
+        if (options.where) {
+            const whereResult = this.buildWhereClause(options.where, 'postgresql', paramIndex);
+            sql += ` WHERE ${whereResult.clause}`;
+            params.push(...whereResult.params);
+            paramIndex += whereResult.params.length;
+        }
+        // GROUP BY clause
+        sql += ` GROUP BY ${groupColumns.join(', ')}`;
+        // HAVING clause
+        if (options.having) {
+            const havingResult = this.buildHavingClause(options.having, 'postgresql', paramIndex);
+            sql += ` HAVING ${havingResult.clause}`;
+            params.push(...havingResult.params);
+            paramIndex += havingResult.params.length;
+        }
+        // ORDER BY clause
+        if (options.orderBy) {
+            const orderClauses = options.orderBy.map(order => {
+                const direction = order.order === 'DESC' ? 'DESC' : 'ASC';
+                return `${this.escapeIdentifier(order.column, 'postgresql')} ${direction}`;
+            });
+            sql += ` ORDER BY ${orderClauses.join(', ')}`;
+        }
+        // LIMIT clause
+        if (options.limit !== undefined) {
+            sql += ` LIMIT $${paramIndex}`;
+            params.push(options.limit);
+            paramIndex++;
+        }
+        // OFFSET clause
+        if (options.offset !== undefined) {
+            sql += ` OFFSET $${paramIndex}`;
+            params.push(options.offset);
+            paramIndex++;
+        }
+        return {
+            options,
+            sql,
+            params,
+        };
+    }
+    // ==================== MYSQL/MARIADB AGGREGATION ====================
+    buildMySQLAggregation(options) {
+        const params = [];
+        // Build SELECT clause with aggregations
+        const selectClauses = this.buildAggregationSelectClauses(options.operations, 'mysql');
+        let sql = `SELECT ${selectClauses.join(', ')} FROM ${this.escapeIdentifier(options.table, 'mysql')}`;
+        // WHERE clause
+        if (options.where) {
+            const whereResult = this.buildWhereClause(options.where, 'mysql', 0);
+            sql += ` WHERE ${whereResult.clause}`;
+            params.push(...whereResult.params);
+        }
+        return {
+            options,
+            sql,
+            params,
+        };
+    }
+    buildMySQLGroupBy(options) {
+        const params = [];
+        // Build SELECT clause with group columns and aggregations
+        const groupColumns = options.groupBy.map(col => this.escapeIdentifier(col, 'mysql'));
+        const aggClauses = this.buildAggregationSelectClauses(options.operations, 'mysql');
+        let sql = `SELECT ${[...groupColumns, ...aggClauses].join(', ')} FROM ${this.escapeIdentifier(options.table, 'mysql')}`;
+        // WHERE clause
+        if (options.where) {
+            const whereResult = this.buildWhereClause(options.where, 'mysql', 0);
+            sql += ` WHERE ${whereResult.clause}`;
+            params.push(...whereResult.params);
+        }
+        // GROUP BY clause
+        sql += ` GROUP BY ${groupColumns.join(', ')}`;
+        // HAVING clause
+        if (options.having) {
+            const havingResult = this.buildHavingClause(options.having, 'mysql', 0);
+            sql += ` HAVING ${havingResult.clause}`;
+            params.push(...havingResult.params);
+        }
+        // ORDER BY clause
+        if (options.orderBy) {
+            const orderClauses = options.orderBy.map(order => {
+                const direction = order.order === 'DESC' ? 'DESC' : 'ASC';
+                return `${this.escapeIdentifier(order.column, 'mysql')} ${direction}`;
+            });
+            sql += ` ORDER BY ${orderClauses.join(', ')}`;
+        }
+        // LIMIT clause
+        if (options.limit !== undefined) {
+            sql += ' LIMIT ?';
+            params.push(options.limit);
+        }
+        // OFFSET clause
+        if (options.offset !== undefined) {
+            sql += ' OFFSET ?';
+            params.push(options.offset);
+        }
+        return {
+            options,
+            sql,
+            params,
+        };
+    }
+    // ==================== MONGODB AGGREGATION ====================
+    buildMongoAggregation(options) {
+        const pipeline = [];
+        // $match stage (WHERE equivalent)
+        if (options.where) {
+            const matchStage = this.buildMongoMatch(options.where);
+            pipeline.push({ $match: matchStage });
+        }
+        // $group stage for aggregations (without grouping columns)
+        const groupStage = { _id: null };
+        for (const [alias, operation] of Object.entries(options.operations)) {
+            Object.assign(groupStage, this.buildMongoAggregationField(alias, operation));
+        }
+        pipeline.push({ $group: groupStage });
+        // $project to remove _id
+        const projectStage = { _id: 0 };
+        for (const alias of Object.keys(options.operations)) {
+            projectStage[alias] = 1;
+        }
+        pipeline.push({ $project: projectStage });
+        return {
+            options,
+            pipeline,
+        };
+    }
+    buildMongoGroupBy(options) {
+        const pipeline = [];
+        // $match stage (WHERE equivalent)
+        if (options.where) {
+            const matchStage = this.buildMongoMatch(options.where);
+            pipeline.push({ $match: matchStage });
+        }
+        // $group stage
+        const groupId = {};
+        for (const col of options.groupBy) {
+            groupId[col] = `$${col}`;
+        }
+        const groupStage = { _id: groupId };
+        for (const [alias, operation] of Object.entries(options.operations)) {
+            Object.assign(groupStage, this.buildMongoAggregationField(alias, operation));
+        }
+        pipeline.push({ $group: groupStage });
+        // $match stage for HAVING
+        if (options.having) {
+            const havingMatch = this.buildMongoHaving(options.having);
+            pipeline.push({ $match: havingMatch });
+        }
+        // $sort stage
+        if (options.orderBy) {
+            const sortStage = {};
+            for (const order of options.orderBy) {
+                // Check if sorting by a group column or an aggregate
+                const isGroupColumn = options.groupBy.includes(order.column);
+                const sortKey = isGroupColumn ? `_id.${order.column}` : order.column;
+                sortStage[sortKey] = order.order === 'DESC' ? -1 : 1;
+            }
+            pipeline.push({ $sort: sortStage });
+        }
+        // $skip stage
+        if (options.offset !== undefined) {
+            pipeline.push({ $skip: options.offset });
+        }
+        // $limit stage
+        if (options.limit !== undefined) {
+            pipeline.push({ $limit: options.limit });
+        }
+        // $project stage to flatten the result
+        const projectStage = { _id: 0 };
+        for (const col of options.groupBy) {
+            projectStage[col] = `$_id.${col}`;
+        }
+        for (const alias of Object.keys(options.operations)) {
+            projectStage[alias] = 1;
+        }
+        pipeline.push({ $project: projectStage });
+        return {
+            options,
+            pipeline,
+        };
+    }
+    buildMongoAggregationField(alias, operation) {
+        if (operation.$COUNT !== undefined) {
+            if (operation.$COUNT === '*') {
+                return { [alias]: { $sum: 1 } };
+            }
+            return { [alias]: { $sum: { $cond: [{ $ne: [`$${operation.$COUNT}`, null] }, 1, 0] } } };
+        }
+        if (operation.$SUM !== undefined) {
+            return { [alias]: { $sum: `$${operation.$SUM}` } };
+        }
+        if (operation.$AVG !== undefined) {
+            return { [alias]: { $avg: `$${operation.$AVG}` } };
+        }
+        if (operation.$MIN !== undefined) {
+            return { [alias]: { $min: `$${operation.$MIN}` } };
+        }
+        if (operation.$MAX !== undefined) {
+            return { [alias]: { $max: `$${operation.$MAX}` } };
+        }
+        if (operation.$ARRAY_AGG !== undefined) {
+            return { [alias]: { $push: `$${operation.$ARRAY_AGG}` } };
+        }
+        if (operation.$STRING_AGG !== undefined || operation.$GROUP_CONCAT !== undefined) {
+            const opts = (operation.$STRING_AGG || operation.$GROUP_CONCAT);
+            // MongoDB doesn't have direct string aggregation, collect as array and join later
+            return { [alias]: { $push: `$${opts.column}` } };
+        }
+        return {};
+    }
+    buildMongoMatch(where) {
+        const match = {};
+        for (const [key, value] of Object.entries(where)) {
+            if (key === '$AND') {
+                const andConditions = Object.entries(value).map(([k, v]) => this.buildMongoMatch({ [k]: v }));
+                match.$and = andConditions;
+                continue;
+            }
+            if (key === '$OR') {
+                const orConditions = Object.entries(value).map(([k, v]) => this.buildMongoMatch({ [k]: v }));
+                match.$or = orConditions;
+                continue;
+            }
+            if (key === '$NOT') {
+                const notCondition = this.buildMongoMatch(value);
+                // Wrap each condition in $not
+                for (const [field, cond] of Object.entries(notCondition)) {
+                    match[field] = { $not: cond };
+                }
+                continue;
+            }
+            if (value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
+                match[key] = this.translateMongoOperators(value);
+            }
+            else {
+                match[key] = value;
+            }
+        }
+        return match;
+    }
+    translateMongoOperators(conditions) {
+        const result = {};
+        for (const [op, val] of Object.entries(conditions)) {
+            switch (op) {
+                case '$EQ':
+                    result.$eq = val;
+                    break;
+                case '$NE':
+                case '$NOT':
+                    result.$ne = val;
+                    break;
+                case '$GT':
+                    result.$gt = val;
+                    break;
+                case '$GTE':
+                    result.$gte = val;
+                    break;
+                case '$LT':
+                    result.$lt = val;
+                    break;
+                case '$LTE':
+                    result.$lte = val;
+                    break;
+                case '$IN':
+                    result.$in = val;
+                    break;
+                case '$NOT_IN':
+                    result.$nin = val;
+                    break;
+                case '$LIKE':
+                    // Convert SQL LIKE to MongoDB regex
+                    const likePattern = String(val).replace(/%/g, '.*').replace(/_/g, '.');
+                    result.$regex = `^${likePattern}$`;
+                    break;
+                case '$ILIKE':
+                    const ilikePattern = String(val).replace(/%/g, '.*').replace(/_/g, '.');
+                    result.$regex = `^${ilikePattern}$`;
+                    result.$options = 'i';
+                    break;
+                case '$IS_NULL':
+                    if (val) {
+                        result.$eq = null;
+                    }
+                    else {
+                        result.$ne = null;
+                    }
+                    break;
+                case '$IS_NOT_NULL':
+                    if (val) {
+                        result.$ne = null;
+                    }
+                    else {
+                        result.$eq = null;
+                    }
+                    break;
+                case '$BETWEEN':
+                    const [min, max] = val;
+                    result.$gte = min;
+                    result.$lte = max;
+                    break;
+                case '$CONTAINS':
+                    result.$elemMatch = { $eq: val };
+                    break;
+                default:
+                    result[op] = val;
+            }
+        }
+        return result;
+    }
+    buildMongoHaving(having) {
+        const match = {};
+        for (const [alias, condition] of Object.entries(having)) {
+            match[alias] = this.translateMongoOperators(condition);
+        }
+        return match;
+    }
+    // ==================== DYNAMODB AGGREGATION ====================
+    buildDynamoAggregation(options) {
+        // DynamoDB doesn't support server-side aggregations
+        // Return the options and handle in the adapter (client-side aggregation)
+        return {
+            options,
+        };
+    }
+    buildDynamoGroupBy(options) {
+        // DynamoDB doesn't support server-side group by
+        // Return the options and handle in the adapter (client-side grouping)
+        return {
+            options,
+        };
+    }
+    // ==================== CASSANDRA AGGREGATION ====================
+    buildCassandraAggregation(options) {
+        const params = [];
+        // Build SELECT clause with aggregations (Cassandra supports limited aggregations)
+        const selectClauses = this.buildAggregationSelectClauses(options.operations, 'cassandra');
+        let sql = `SELECT ${selectClauses.join(', ')} FROM ${this.escapeIdentifier(options.table, 'cassandra')}`;
+        // WHERE clause
+        if (options.where) {
+            const whereResult = this.buildWhereClause(options.where, 'cassandra', 0);
+            sql += ` WHERE ${whereResult.clause}`;
+            params.push(...whereResult.params);
+        }
+        return {
+            options,
+            sql,
+            params,
+        };
+    }
+    buildCassandraGroupBy(options) {
+        const params = [];
+        // Build SELECT clause with group columns and aggregations
+        const groupColumns = options.groupBy.map(col => this.escapeIdentifier(col, 'cassandra'));
+        const aggClauses = this.buildAggregationSelectClauses(options.operations, 'cassandra');
+        let sql = `SELECT ${[...groupColumns, ...aggClauses].join(', ')} FROM ${this.escapeIdentifier(options.table, 'cassandra')}`;
+        // WHERE clause
+        if (options.where) {
+            const whereResult = this.buildWhereClause(options.where, 'cassandra', 0);
+            sql += ` WHERE ${whereResult.clause}`;
+            params.push(...whereResult.params);
+        }
+        // GROUP BY clause (Cassandra 3.10+)
+        sql += ` GROUP BY ${groupColumns.join(', ')}`;
+        // Note: Cassandra doesn't support HAVING - would need client-side filtering
+        // ORDER BY clause (limited in Cassandra)
+        if (options.orderBy) {
+            const orderClauses = options.orderBy.map(order => {
+                const direction = order.order === 'DESC' ? 'DESC' : 'ASC';
+                return `${order.column} ${direction}`;
+            });
+            sql += ` ORDER BY ${orderClauses.join(', ')}`;
+        }
+        // LIMIT clause
+        if (options.limit !== undefined) {
+            sql += ' LIMIT ?';
+            params.push(options.limit);
+        }
+        // Note: Cassandra doesn't support OFFSET natively
+        return {
+            options,
+            sql,
+            params,
+        };
+    }
+    // ==================== HELPER METHODS ====================
+    buildAggregationSelectClauses(operations, dbType) {
+        const clauses = [];
+        for (const [alias, operation] of Object.entries(operations)) {
+            const clause = this.buildSingleAggregation(alias, operation, dbType);
+            if (clause) {
+                clauses.push(clause);
+            }
+        }
+        return clauses;
+    }
+    buildSingleAggregation(alias, operation, dbType) {
+        const escapedAlias = this.escapeIdentifier(alias, dbType);
+        if (operation.$COUNT !== undefined) {
+            const col = operation.$COUNT === '*' ? '*' : this.escapeIdentifier(operation.$COUNT, dbType);
+            return `COUNT(${col}) AS ${escapedAlias}`;
+        }
+        if (operation.$SUM !== undefined) {
+            return `SUM(${this.escapeIdentifier(operation.$SUM, dbType)}) AS ${escapedAlias}`;
+        }
+        if (operation.$AVG !== undefined) {
+            return `AVG(${this.escapeIdentifier(operation.$AVG, dbType)}) AS ${escapedAlias}`;
+        }
+        if (operation.$MIN !== undefined) {
+            return `MIN(${this.escapeIdentifier(operation.$MIN, dbType)}) AS ${escapedAlias}`;
+        }
+        if (operation.$MAX !== undefined) {
+            return `MAX(${this.escapeIdentifier(operation.$MAX, dbType)}) AS ${escapedAlias}`;
+        }
+        if (operation.$STRING_AGG !== undefined) {
+            return this.buildStringAggregation(alias, operation.$STRING_AGG, dbType);
+        }
+        if (operation.$GROUP_CONCAT !== undefined) {
+            return this.buildStringAggregation(alias, operation.$GROUP_CONCAT, dbType);
+        }
+        if (operation.$ARRAY_AGG !== undefined) {
+            if (dbType === 'postgresql') {
+                return `ARRAY_AGG(${this.escapeIdentifier(operation.$ARRAY_AGG, dbType)}) AS ${escapedAlias}`;
+            }
+            // Not supported in MySQL/Cassandra
+            throw new Error(`$ARRAY_AGG is not supported for ${dbType}`);
+        }
+        return null;
+    }
+    buildStringAggregation(alias, options, dbType) {
+        const escapedAlias = this.escapeIdentifier(alias, dbType);
+        const escapedColumn = this.escapeIdentifier(options.column, dbType);
+        const separator = options.separator || ',';
+        if (dbType === 'postgresql') {
+            let agg = options.distinct
+                ? `STRING_AGG(DISTINCT ${escapedColumn}, '${separator}'`
+                : `STRING_AGG(${escapedColumn}, '${separator}'`;
+            if (options.orderBy) {
+                agg += ` ORDER BY ${this.escapeIdentifier(options.orderBy, dbType)}`;
+            }
+            agg += ')';
+            return `${agg} AS ${escapedAlias}`;
+        }
+        if (dbType === 'mysql' || dbType === 'mariadb') {
+            let agg = options.distinct
+                ? `GROUP_CONCAT(DISTINCT ${escapedColumn}`
+                : `GROUP_CONCAT(${escapedColumn}`;
+            if (options.orderBy) {
+                agg += ` ORDER BY ${this.escapeIdentifier(options.orderBy, dbType)}`;
+            }
+            agg += ` SEPARATOR '${separator}')`;
+            return `${agg} AS ${escapedAlias}`;
+        }
+        throw new Error(`String aggregation is not supported for ${dbType}`);
+    }
+    buildWhereClause(where, dbType, startIndex) {
+        const clauses = [];
+        const params = [];
+        let paramIndex = startIndex;
+        for (const [key, value] of Object.entries(where)) {
+            if (key === '$AND') {
+                const andResults = Object.entries(value).map(([k, v]) => this.buildWhereClause({ [k]: v }, dbType, paramIndex));
+                const andClauses = andResults.map(r => r.clause);
+                andResults.forEach(r => {
+                    params.push(...r.params);
+                    paramIndex += r.params.length;
+                });
+                clauses.push(`(${andClauses.join(' AND ')})`);
+                continue;
+            }
+            if (key === '$OR') {
+                const orResults = Object.entries(value).map(([k, v]) => this.buildWhereClause({ [k]: v }, dbType, paramIndex));
+                const orClauses = orResults.map(r => r.clause);
+                orResults.forEach(r => {
+                    params.push(...r.params);
+                    paramIndex += r.params.length;
+                });
+                clauses.push(`(${orClauses.join(' OR ')})`);
+                continue;
+            }
+            if (key === '$NOT') {
+                const notResult = this.buildWhereClause(value, dbType, paramIndex);
+                clauses.push(`NOT (${notResult.clause})`);
+                params.push(...notResult.params);
+                paramIndex += notResult.params.length;
+                continue;
+            }
+            if (value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
+                for (const [op, opValue] of Object.entries(value)) {
+                    const result = this.buildComparisonClause(key, op, opValue, dbType, paramIndex);
+                    clauses.push(result.clause);
+                    if (result.params.length > 0) {
+                        params.push(...result.params);
+                        paramIndex += result.params.length;
+                    }
+                }
+            }
+            else {
+                const placeholder = this.getPlaceholder(dbType, paramIndex);
+                clauses.push(`${this.escapeIdentifier(key, dbType)} = ${placeholder}`);
+                params.push(value);
+                paramIndex++;
+            }
+        }
+        return {
+            clause: clauses.join(' AND '),
+            params,
+        };
+    }
+    buildComparisonClause(field, operator, value, dbType, paramIndex) {
+        const escapedField = this.escapeIdentifier(field, dbType);
+        const placeholder = this.getPlaceholder(dbType, paramIndex);
+        switch (operator) {
+            case '$EQ':
+                return { clause: `${escapedField} = ${placeholder}`, params: [value] };
+            case '$NE':
+            case '$NOT':
+                return { clause: `${escapedField} != ${placeholder}`, params: [value] };
+            case '$GT':
+                return { clause: `${escapedField} > ${placeholder}`, params: [value] };
+            case '$GTE':
+                return { clause: `${escapedField} >= ${placeholder}`, params: [value] };
+            case '$LT':
+                return { clause: `${escapedField} < ${placeholder}`, params: [value] };
+            case '$LTE':
+                return { clause: `${escapedField} <= ${placeholder}`, params: [value] };
+            case '$IN':
+                if (dbType === 'postgresql') {
+                    return { clause: `${escapedField} = ANY(${placeholder})`, params: [value] };
+                }
+                return { clause: `${escapedField} IN (${placeholder})`, params: [value] };
+            case '$NOT_IN':
+                if (dbType === 'postgresql') {
+                    return { clause: `${escapedField} != ALL(${placeholder})`, params: [value] };
+                }
+                return { clause: `${escapedField} NOT IN (${placeholder})`, params: [value] };
+            case '$LIKE':
+                return { clause: `${escapedField} LIKE ${placeholder}`, params: [value] };
+            case '$ILIKE':
+                if (dbType === 'postgresql') {
+                    return { clause: `${escapedField} ILIKE ${placeholder}`, params: [value] };
+                }
+                return { clause: `LOWER(${escapedField}) LIKE LOWER(${placeholder})`, params: [value] };
+            case '$IS_NULL':
+                return { clause: `${escapedField} IS ${value ? 'NULL' : 'NOT NULL'}`, params: [] };
+            case '$IS_NOT_NULL':
+                return { clause: `${escapedField} IS ${value ? 'NOT NULL' : 'NULL'}`, params: [] };
+            case '$BETWEEN':
+                const [min, max] = value;
+                if (dbType === 'postgresql') {
+                    return {
+                        clause: `${escapedField} BETWEEN $${paramIndex} AND $${paramIndex + 1}`,
+                        params: [min, max],
+                    };
+                }
+                return {
+                    clause: `${escapedField} BETWEEN ? AND ?`,
+                    params: [min, max],
+                };
+            default:
+                throw new Error(`Unknown operator: ${operator}`);
+        }
+    }
+    buildHavingClause(having, dbType, startIndex) {
+        const clauses = [];
+        const params = [];
+        let paramIndex = startIndex;
+        for (const [alias, condition] of Object.entries(having)) {
+            for (const [op, value] of Object.entries(condition)) {
+                const result = this.buildHavingCondition(alias, op, value, dbType, paramIndex);
+                clauses.push(result.clause);
+                params.push(...result.params);
+                paramIndex += result.params.length;
+            }
+        }
+        return {
+            clause: clauses.join(' AND '),
+            params,
+        };
+    }
+    buildHavingCondition(alias, operator, value, dbType, paramIndex) {
+        const escapedAlias = this.escapeIdentifier(alias, dbType);
+        const placeholder = this.getPlaceholder(dbType, paramIndex);
+        switch (operator) {
+            case '$GT':
+                return { clause: `${escapedAlias} > ${placeholder}`, params: [value] };
+            case '$GTE':
+                return { clause: `${escapedAlias} >= ${placeholder}`, params: [value] };
+            case '$LT':
+                return { clause: `${escapedAlias} < ${placeholder}`, params: [value] };
+            case '$LTE':
+                return { clause: `${escapedAlias} <= ${placeholder}`, params: [value] };
+            case '$EQ':
+                return { clause: `${escapedAlias} = ${placeholder}`, params: [value] };
+            case '$NE':
+                return { clause: `${escapedAlias} != ${placeholder}`, params: [value] };
+            case '$BETWEEN':
+                const [min, max] = value;
+                if (dbType === 'postgresql') {
+                    return {
+                        clause: `${escapedAlias} BETWEEN $${paramIndex} AND $${paramIndex + 1}`,
+                        params: [min, max],
+                    };
+                }
+                return {
+                    clause: `${escapedAlias} BETWEEN ? AND ?`,
+                    params: [min, max],
+                };
+            default:
+                throw new Error(`Unknown HAVING operator: ${operator}`);
+        }
+    }
+    escapeIdentifier(identifier, dbType) {
+        switch (dbType) {
+            case 'postgresql':
+                return `"${identifier.replace(/"/g, '""')}"`;
+            case 'mysql':
+            case 'mariadb':
+                return `\`${identifier.replace(/`/g, '``')}\``;
+            case 'cassandra':
+                if (/[^a-zA-Z0-9_]/.test(identifier)) {
+                    return `"${identifier.replace(/"/g, '""')}"`;
+                }
+                return identifier;
+            default:
+                return identifier;
+        }
+    }
+    getPlaceholder(dbType, index) {
+        switch (dbType) {
+            case 'postgresql':
+                return `$${index}`;
+            case 'mysql':
+            case 'mariadb':
+            case 'cassandra':
+                return '?';
+            default:
+                return '?';
+        }
+    }
+}
+exports.AggregationBuilder = AggregationBuilder;
+/**
+ * Export aggregation operators for external use
+ */
+exports.AggregationOperators = {
+    $COUNT: '$COUNT',
+    $SUM: '$SUM',
+    $AVG: '$AVG',
+    $MIN: '$MIN',
+    $MAX: '$MAX',
+    $STRING_AGG: '$STRING_AGG',
+    $GROUP_CONCAT: '$GROUP_CONCAT',
+    $ARRAY_AGG: '$ARRAY_AGG',
+};
+//# sourceMappingURL=aggregation-builder.js.map