@visactor/vquery 0.4.7 → 0.4.9

package/dist/browser/esm/browser.js

@@ -123,7 +123,7 @@ const applySelect = (qb, select)=>{
                 const expression = eb.ref(field);
                 if (item.aggr) {
                     const { func } = item.aggr;
-                    const alias = item.alias ?? field;
+                    const sqlAlias = field;
                     if ([
                         'avg',
                         'sum',
@@ -134,29 +134,99 @@ const applySelect = (qb, select)=>{
                         'stddev',
                         'median'
                     ].includes(func)) {
-                        if ('variance' === func) return external_kysely_sql`var_samp(${expression})`.as(alias);
-                        if ('variancePop' === func) return external_kysely_sql`var_pop(${expression})`.as(alias);
-                        return external_kysely_sql`${external_kysely_sql.raw(func)}(${expression})`.as(alias);
+                        if ('variance' === func) return external_kysely_sql`var_samp(${expression})`.as(sqlAlias);
+                        if ('variancePop' === func) return external_kysely_sql`var_pop(${expression})`.as(sqlAlias);
+                        return external_kysely_sql`${external_kysely_sql.raw(func)}(${expression})`.as(sqlAlias);
                     }
-                    if ('count' === func) return external_kysely_sql`CAST(count(${expression}) AS INTEGER)`.as(alias);
+                    if ('count' === func) return external_kysely_sql`CAST(count(${expression}) AS INTEGER)`.as(sqlAlias);
                     if ('quantile' === func) {
                         const q = item.aggr.quantile ?? 0.5;
-                        return external_kysely_sql`quantile(${expression}, ${q})`.as(alias);
-                    } else if ('count_distinct' === func) return external_kysely_sql`CAST(count(distinct ${expression}) AS INTEGER)`.as(alias);
+                        return external_kysely_sql`quantile(${expression}, ${q})`.as(sqlAlias);
+                    } else if ('count_distinct' === func) return external_kysely_sql`CAST(count(distinct ${expression}) AS INTEGER)`.as(sqlAlias);
                     else if (func.startsWith('to_')) {
                         const dateTrunc = func.replace('to_', '');
                         const format = DATE_FORMAT_MAP[dateTrunc];
-                        if (format) return external_kysely_sql`strftime(CAST(${expression} AS TIMESTAMP), ${format})`.as(alias);
-                        if ('quarter' === dateTrunc) return external_kysely_sql`strftime(CAST(${expression} AS TIMESTAMP), '%Y') || '-Q' || date_part('quarter', CAST(${expression} AS TIMESTAMP))`.as(alias);
+                        if (format) return external_kysely_sql`strftime(CAST(${expression} AS TIMESTAMP), ${format})`.as(sqlAlias);
+                        if ('quarter' === dateTrunc) return external_kysely_sql`strftime(CAST(${expression} AS TIMESTAMP), '%Y') || '-Q' || date_part('quarter', CAST(${expression} AS TIMESTAMP))`.as(sqlAlias);
                     }
                 }
-                const alias = item.alias ?? field;
-                return expression.as(alias);
+                return expression.as(field);
             }
             return item;
         }));
     return qb.selectAll();
 };
+const applyHaving = (having)=>{
+    const toRaw = (h)=>{
+        if ('op' in h && 'conditions' in h) {
+            const parts = h.conditions.map((c)=>toRaw(c));
+            const sep = external_kysely_sql` ${external_kysely_sql.raw(h.op)} `;
+            return external_kysely_sql`(${external_kysely_sql.join(parts, sep)})`;
+        }
+        const leaf = h;
+        const field = leaf.field;
+        const value = leaf.value;
+        const op = leaf.op;
+        if ([
+            'sum',
+            'avg',
+            'count',
+            'min',
+            'max'
+        ].includes(op)) {
+            const aggrExpr = external_kysely_sql`${external_kysely_sql.raw(op.toLowerCase())}(${external_kysely_sql.ref(field)})`;
+            return external_kysely_sql`${aggrExpr} = ${external_kysely_sql.val(value)}`;
+        }
+        switch(op){
+            case 'is null':
+                return external_kysely_sql`${external_kysely_sql.ref(field)} is null`;
+            case 'is not null':
+                return external_kysely_sql`${external_kysely_sql.ref(field)} is not null`;
+            case 'in':
+                {
+                    const items = Array.isArray(value) ? value : [
+                        value
+                    ];
+                    return external_kysely_sql`${external_kysely_sql.ref(field)} in (${external_kysely_sql.join(items.map((v)=>external_kysely_sql.val(v)))})`;
+                }
+            case 'not in':
+                {
+                    const items = Array.isArray(value) ? value : [
+                        value
+                    ];
+                    return external_kysely_sql`not ${external_kysely_sql.ref(field)} in (${external_kysely_sql.join(items.map((v)=>external_kysely_sql.val(v)))})`;
+                }
+            case 'between':
+                {
+                    const [a, b] = value;
+                    return external_kysely_sql`${external_kysely_sql.ref(field)} between ${external_kysely_sql.val(a)} and ${external_kysely_sql.val(b)}`;
+                }
+            case 'not between':
+                {
+                    const [a, b] = value;
+                    return external_kysely_sql`${external_kysely_sql.ref(field)} not between ${external_kysely_sql.val(a)} and ${external_kysely_sql.val(b)}`;
+                }
+            default:
+                return external_kysely_sql`${external_kysely_sql.ref(field)} ${external_kysely_sql.raw(op)} ${external_kysely_sql.val(value)}`;
+        }
+    };
+    return toRaw(having);
+};
+const resolveHavingAliases = (having, aliasToFieldMap)=>{
+    if (!having) return having;
+    if ('op' in having && 'conditions' in having) return {
+        ...having,
+        conditions: having.conditions.map((c)=>resolveHavingAliases(c, aliasToFieldMap))
+    };
+    if ('field' in having) {
+        const resolvedField = aliasToFieldMap[having.field] || having.field;
+        return {
+            ...having,
+            field: resolvedField
+        };
+    }
+    return having;
+};
 const convertDSLToSQL = (dsl, tableName)=>{
     const db = new Kysely({
         dialect: new PostgresDialect()
@@ -164,8 +234,26 @@ const convertDSLToSQL = (dsl, tableName)=>{
     let qb = db.selectFrom(tableName);
     qb = applySelect(qb, dsl.select);
     if (dsl.where) qb = qb.where(applyWhere(dsl.where));
-    qb = applyGroupBy(qb, dsl.groupBy);
-    if (dsl.orderBy && dsl.orderBy.length > 0) for (const o of dsl.orderBy)qb = qb.orderBy(o.field, o.order ?? 'asc');
+    const aliasToFieldMap = {};
+    if (dsl.select && Array.isArray(dsl.select)) {
+        for (const item of dsl.select)if ('object' == typeof item && null !== item) {
+            const field = item.field;
+            const alias = item.alias;
+            if (alias && field) aliasToFieldMap[alias] = field;
+        }
+    }
+    let resolvedGroupBy = dsl.groupBy;
+    if (dsl.groupBy && dsl.groupBy.length > 0) resolvedGroupBy = dsl.groupBy.map((g)=>aliasToFieldMap[g] || g);
+    qb = applyGroupBy(qb, resolvedGroupBy);
+    if (dsl.having) {
+        const resolvedHaving = resolveHavingAliases(dsl.having, aliasToFieldMap);
+        qb = qb.having(applyHaving(resolvedHaving));
+    }
+    if (dsl.orderBy && dsl.orderBy.length > 0) for (const o of dsl.orderBy){
+        const fieldStr = o.field;
+        const resolvedField = aliasToFieldMap[fieldStr] || fieldStr;
+        qb = qb.orderBy(resolvedField, o.order ?? 'asc');
+    }
     qb = applyLimit(qb, dsl.limit);
     const compiled = qb.compile();
     return inlineParameters(compiled.sql, compiled.parameters);

package/dist/browser/esm/sql-builder/builders/having.d.ts

@@ -0,0 +1,3 @@
+import { Having, HavingClause } from '../../types';
+import type { RawBuilder } from 'kysely';
+export declare const applyHaving: <T>(having: Having<T> | HavingClause<T>) => RawBuilder<boolean>;

package/dist/browser/esm/sql-builder/builders/index.d.ts

@@ -2,3 +2,4 @@ export { applyWhere } from './where';
 export { applyGroupBy } from './groupBy';
 export { applyLimit } from './limit';
 export { applySelect } from './select';
+export { applyHaving } from './having';

package/dist/browser/esm/types/dsl/Having.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Having 子句类型定义
+ * 用于聚合后的数据筛选
+ */
+export type Having<T> = HavingGroup<T>;
+export type HavingGroup<T> = {
+    op: 'and' | 'or';
+    conditions: Array<HavingClause<T>>;
+};
+export type HavingClause<T> = HavingLeaf<T> | HavingGroup<T>;
+/**
+ * Having 叶子节点
+ * 支持聚合函数操作符
+ */
+export type HavingLeaf<T> = {
+    [K in keyof T]: {
+        [O in HavingOperator]: {
+            field: K;
+            op: O;
+        } & (O extends 'is null' | 'is not null' ? {
+            value?: never;
+        } : O extends 'in' | 'not in' ? {
+            value: T[K] | T[K][];
+        } : O extends 'between' | 'not between' ? {
+            value: [T[K], T[K]];
+        } : {
+            value: T[K];
+        });
+    }[HavingOperator];
+}[keyof T];
+/**
+ * Having 操作符
+ * 聚合函数操作符
+ */
+export type HavingOperator = 'sum' | 'avg' | 'count' | 'min' | 'max' | '=' | '!=' | '>' | '>=' | '<' | '<=' | 'between' | 'not between' | 'in' | 'not in' | 'is null' | 'is not null';

package/dist/browser/esm/types/dsl/QueryDSL.d.ts

@@ -2,10 +2,12 @@ import { GroupBy } from './GroupBy';
 import { OrderBy } from './OrderBy';
 import { Select } from './Select';
 import { Where } from './Where';
+import { Having } from './Having';
 export interface QueryDSL<Table> {
     select: Select<Table>;
     where?: Where<Table>;
     groupBy?: GroupBy<Table>;
+    having?: Having<Table>;
     orderBy?: OrderBy<Table>;
     limit?: number;
 }

package/dist/browser/esm/types/dsl/index.d.ts

@@ -3,3 +3,4 @@ export type { GroupBy } from './GroupBy';
 export type { OrderBy } from './OrderBy';
 export type { Select } from './Select';
 export type { Where, WhereClause, WhereLeaf, WhereGroup } from './Where';
+export type { Having, HavingClause, HavingLeaf, HavingGroup, HavingOperator } from './Having';

package/dist/node/cjs/node.cjs

@@ -161,7 +161,7 @@ const applySelect = (qb, select)=>{
                 const expression = eb.ref(field);
                 if (item.aggr) {
                     const { func } = item.aggr;
-                    const alias = item.alias ?? field;
+                    const sqlAlias = field;
                     if ([
                         'avg',
                         'sum',
@@ -172,29 +172,99 @@ const applySelect = (qb, select)=>{
                         'stddev',
                         'median'
                     ].includes(func)) {
-                        if ('variance' === func) return (0, external_kysely_namespaceObject.sql)`var_samp(${expression})`.as(alias);
-                        if ('variancePop' === func) return (0, external_kysely_namespaceObject.sql)`var_pop(${expression})`.as(alias);
-                        return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.raw(func)}(${expression})`.as(alias);
+                        if ('variance' === func) return (0, external_kysely_namespaceObject.sql)`var_samp(${expression})`.as(sqlAlias);
+                        if ('variancePop' === func) return (0, external_kysely_namespaceObject.sql)`var_pop(${expression})`.as(sqlAlias);
+                        return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.raw(func)}(${expression})`.as(sqlAlias);
                     }
-                    if ('count' === func) return (0, external_kysely_namespaceObject.sql)`CAST(count(${expression}) AS INTEGER)`.as(alias);
+                    if ('count' === func) return (0, external_kysely_namespaceObject.sql)`CAST(count(${expression}) AS INTEGER)`.as(sqlAlias);
                     if ('quantile' === func) {
                         const q = item.aggr.quantile ?? 0.5;
-                        return (0, external_kysely_namespaceObject.sql)`quantile(${expression}, ${q})`.as(alias);
-                    } else if ('count_distinct' === func) return (0, external_kysely_namespaceObject.sql)`CAST(count(distinct ${expression}) AS INTEGER)`.as(alias);
+                        return (0, external_kysely_namespaceObject.sql)`quantile(${expression}, ${q})`.as(sqlAlias);
+                    } else if ('count_distinct' === func) return (0, external_kysely_namespaceObject.sql)`CAST(count(distinct ${expression}) AS INTEGER)`.as(sqlAlias);
                     else if (func.startsWith('to_')) {
                         const dateTrunc = func.replace('to_', '');
                         const format = DATE_FORMAT_MAP[dateTrunc];
-                        if (format) return (0, external_kysely_namespaceObject.sql)`strftime(CAST(${expression} AS TIMESTAMP), ${format})`.as(alias);
-                        if ('quarter' === dateTrunc) return (0, external_kysely_namespaceObject.sql)`strftime(CAST(${expression} AS TIMESTAMP), '%Y') || '-Q' || date_part('quarter', CAST(${expression} AS TIMESTAMP))`.as(alias);
+                        if (format) return (0, external_kysely_namespaceObject.sql)`strftime(CAST(${expression} AS TIMESTAMP), ${format})`.as(sqlAlias);
+                        if ('quarter' === dateTrunc) return (0, external_kysely_namespaceObject.sql)`strftime(CAST(${expression} AS TIMESTAMP), '%Y') || '-Q' || date_part('quarter', CAST(${expression} AS TIMESTAMP))`.as(sqlAlias);
                     }
                 }
-                const alias = item.alias ?? field;
-                return expression.as(alias);
+                return expression.as(field);
             }
             return item;
         }));
     return qb.selectAll();
 };
+const applyHaving = (having)=>{
+    const toRaw = (h)=>{
+        if ('op' in h && 'conditions' in h) {
+            const parts = h.conditions.map((c)=>toRaw(c));
+            const sep = (0, external_kysely_namespaceObject.sql)` ${external_kysely_namespaceObject.sql.raw(h.op)} `;
+            return (0, external_kysely_namespaceObject.sql)`(${external_kysely_namespaceObject.sql.join(parts, sep)})`;
+        }
+        const leaf = h;
+        const field = leaf.field;
+        const value = leaf.value;
+        const op = leaf.op;
+        if ([
+            'sum',
+            'avg',
+            'count',
+            'min',
+            'max'
+        ].includes(op)) {
+            const aggrExpr = (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.raw(op.toLowerCase())}(${external_kysely_namespaceObject.sql.ref(field)})`;
+            return (0, external_kysely_namespaceObject.sql)`${aggrExpr} = ${external_kysely_namespaceObject.sql.val(value)}`;
+        }
+        switch(op){
+            case 'is null':
+                return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.ref(field)} is null`;
+            case 'is not null':
+                return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.ref(field)} is not null`;
+            case 'in':
+                {
+                    const items = Array.isArray(value) ? value : [
+                        value
+                    ];
+                    return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.ref(field)} in (${external_kysely_namespaceObject.sql.join(items.map((v)=>external_kysely_namespaceObject.sql.val(v)))})`;
+                }
+            case 'not in':
+                {
+                    const items = Array.isArray(value) ? value : [
+                        value
+                    ];
+                    return (0, external_kysely_namespaceObject.sql)`not ${external_kysely_namespaceObject.sql.ref(field)} in (${external_kysely_namespaceObject.sql.join(items.map((v)=>external_kysely_namespaceObject.sql.val(v)))})`;
+                }
+            case 'between':
+                {
+                    const [a, b] = value;
+                    return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.ref(field)} between ${external_kysely_namespaceObject.sql.val(a)} and ${external_kysely_namespaceObject.sql.val(b)}`;
+                }
+            case 'not between':
+                {
+                    const [a, b] = value;
+                    return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.ref(field)} not between ${external_kysely_namespaceObject.sql.val(a)} and ${external_kysely_namespaceObject.sql.val(b)}`;
+                }
+            default:
+                return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.ref(field)} ${external_kysely_namespaceObject.sql.raw(op)} ${external_kysely_namespaceObject.sql.val(value)}`;
+        }
+    };
+    return toRaw(having);
+};
+const resolveHavingAliases = (having, aliasToFieldMap)=>{
+    if (!having) return having;
+    if ('op' in having && 'conditions' in having) return {
+        ...having,
+        conditions: having.conditions.map((c)=>resolveHavingAliases(c, aliasToFieldMap))
+    };
+    if ('field' in having) {
+        const resolvedField = aliasToFieldMap[having.field] || having.field;
+        return {
+            ...having,
+            field: resolvedField
+        };
+    }
+    return having;
+};
 const convertDSLToSQL = (dsl, tableName)=>{
     const db = new external_kysely_namespaceObject.Kysely({
         dialect: new PostgresDialect()
@@ -202,8 +272,26 @@ const convertDSLToSQL = (dsl, tableName)=>{
     let qb = db.selectFrom(tableName);
     qb = applySelect(qb, dsl.select);
     if (dsl.where) qb = qb.where(applyWhere(dsl.where));
-    qb = applyGroupBy(qb, dsl.groupBy);
-    if (dsl.orderBy && dsl.orderBy.length > 0) for (const o of dsl.orderBy)qb = qb.orderBy(o.field, o.order ?? 'asc');
+    const aliasToFieldMap = {};
+    if (dsl.select && Array.isArray(dsl.select)) {
+        for (const item of dsl.select)if ('object' == typeof item && null !== item) {
+            const field = item.field;
+            const alias = item.alias;
+            if (alias && field) aliasToFieldMap[alias] = field;
+        }
+    }
+    let resolvedGroupBy = dsl.groupBy;
+    if (dsl.groupBy && dsl.groupBy.length > 0) resolvedGroupBy = dsl.groupBy.map((g)=>aliasToFieldMap[g] || g);
+    qb = applyGroupBy(qb, resolvedGroupBy);
+    if (dsl.having) {
+        const resolvedHaving = resolveHavingAliases(dsl.having, aliasToFieldMap);
+        qb = qb.having(applyHaving(resolvedHaving));
+    }
+    if (dsl.orderBy && dsl.orderBy.length > 0) for (const o of dsl.orderBy){
+        const fieldStr = o.field;
+        const resolvedField = aliasToFieldMap[fieldStr] || fieldStr;
+        qb = qb.orderBy(resolvedField, o.order ?? 'asc');
+    }
     qb = applyLimit(qb, dsl.limit);
     const compiled = qb.compile();
     return inlineParameters(compiled.sql, compiled.parameters);

package/dist/node/cjs/sql-builder/builders/having.d.ts

@@ -0,0 +1,3 @@
+import { Having, HavingClause } from '../../types';
+import type { RawBuilder } from 'kysely';
+export declare const applyHaving: <T>(having: Having<T> | HavingClause<T>) => RawBuilder<boolean>;

package/dist/node/cjs/sql-builder/builders/index.d.ts

@@ -2,3 +2,4 @@ export { applyWhere } from './where';
 export { applyGroupBy } from './groupBy';
 export { applyLimit } from './limit';
 export { applySelect } from './select';
+export { applyHaving } from './having';

package/dist/node/cjs/types/dsl/Having.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Having 子句类型定义
+ * 用于聚合后的数据筛选
+ */
+export type Having<T> = HavingGroup<T>;
+export type HavingGroup<T> = {
+    op: 'and' | 'or';
+    conditions: Array<HavingClause<T>>;
+};
+export type HavingClause<T> = HavingLeaf<T> | HavingGroup<T>;
+/**
+ * Having 叶子节点
+ * 支持聚合函数操作符
+ */
+export type HavingLeaf<T> = {
+    [K in keyof T]: {
+        [O in HavingOperator]: {
+            field: K;
+            op: O;
+        } & (O extends 'is null' | 'is not null' ? {
+            value?: never;
+        } : O extends 'in' | 'not in' ? {
+            value: T[K] | T[K][];
+        } : O extends 'between' | 'not between' ? {
+            value: [T[K], T[K]];
+        } : {
+            value: T[K];
+        });
+    }[HavingOperator];
+}[keyof T];
+/**
+ * Having 操作符
+ * 聚合函数操作符
+ */
+export type HavingOperator = 'sum' | 'avg' | 'count' | 'min' | 'max' | '=' | '!=' | '>' | '>=' | '<' | '<=' | 'between' | 'not between' | 'in' | 'not in' | 'is null' | 'is not null';

package/dist/node/cjs/types/dsl/QueryDSL.d.ts

@@ -2,10 +2,12 @@ import { GroupBy } from './GroupBy';
 import { OrderBy } from './OrderBy';
 import { Select } from './Select';
 import { Where } from './Where';
+import { Having } from './Having';
 export interface QueryDSL<Table> {
     select: Select<Table>;
     where?: Where<Table>;
     groupBy?: GroupBy<Table>;
+    having?: Having<Table>;
     orderBy?: OrderBy<Table>;
     limit?: number;
 }

package/dist/node/cjs/types/dsl/index.d.ts

@@ -3,3 +3,4 @@ export type { GroupBy } from './GroupBy';
 export type { OrderBy } from './OrderBy';
 export type { Select } from './Select';
 export type { Where, WhereClause, WhereLeaf, WhereGroup } from './Where';
+export type { Having, HavingClause, HavingLeaf, HavingGroup, HavingOperator } from './Having';

package/dist/node/esm/node.js

@@ -124,7 +124,7 @@ const applySelect = (qb, select)=>{
                 const expression = eb.ref(field);
                 if (item.aggr) {
                     const { func } = item.aggr;
-                    const alias = item.alias ?? field;
+                    const sqlAlias = field;
                     if ([
                         'avg',
                         'sum',
@@ -135,29 +135,99 @@ const applySelect = (qb, select)=>{
                         'stddev',
                         'median'
                     ].includes(func)) {
-                        if ('variance' === func) return external_kysely_sql`var_samp(${expression})`.as(alias);
-                        if ('variancePop' === func) return external_kysely_sql`var_pop(${expression})`.as(alias);
-                        return external_kysely_sql`${external_kysely_sql.raw(func)}(${expression})`.as(alias);
+                        if ('variance' === func) return external_kysely_sql`var_samp(${expression})`.as(sqlAlias);
+                        if ('variancePop' === func) return external_kysely_sql`var_pop(${expression})`.as(sqlAlias);
+                        return external_kysely_sql`${external_kysely_sql.raw(func)}(${expression})`.as(sqlAlias);
                     }
-                    if ('count' === func) return external_kysely_sql`CAST(count(${expression}) AS INTEGER)`.as(alias);
+                    if ('count' === func) return external_kysely_sql`CAST(count(${expression}) AS INTEGER)`.as(sqlAlias);
                     if ('quantile' === func) {
                         const q = item.aggr.quantile ?? 0.5;
-                        return external_kysely_sql`quantile(${expression}, ${q})`.as(alias);
-                    } else if ('count_distinct' === func) return external_kysely_sql`CAST(count(distinct ${expression}) AS INTEGER)`.as(alias);
+                        return external_kysely_sql`quantile(${expression}, ${q})`.as(sqlAlias);
+                    } else if ('count_distinct' === func) return external_kysely_sql`CAST(count(distinct ${expression}) AS INTEGER)`.as(sqlAlias);
                     else if (func.startsWith('to_')) {
                         const dateTrunc = func.replace('to_', '');
                         const format = DATE_FORMAT_MAP[dateTrunc];
-                        if (format) return external_kysely_sql`strftime(CAST(${expression} AS TIMESTAMP), ${format})`.as(alias);
-                        if ('quarter' === dateTrunc) return external_kysely_sql`strftime(CAST(${expression} AS TIMESTAMP), '%Y') || '-Q' || date_part('quarter', CAST(${expression} AS TIMESTAMP))`.as(alias);
+                        if (format) return external_kysely_sql`strftime(CAST(${expression} AS TIMESTAMP), ${format})`.as(sqlAlias);
+                        if ('quarter' === dateTrunc) return external_kysely_sql`strftime(CAST(${expression} AS TIMESTAMP), '%Y') || '-Q' || date_part('quarter', CAST(${expression} AS TIMESTAMP))`.as(sqlAlias);
                     }
                 }
-                const alias = item.alias ?? field;
-                return expression.as(alias);
+                return expression.as(field);
             }
             return item;
         }));
     return qb.selectAll();
 };
+const applyHaving = (having)=>{
+    const toRaw = (h)=>{
+        if ('op' in h && 'conditions' in h) {
+            const parts = h.conditions.map((c)=>toRaw(c));
+            const sep = external_kysely_sql` ${external_kysely_sql.raw(h.op)} `;
+            return external_kysely_sql`(${external_kysely_sql.join(parts, sep)})`;
+        }
+        const leaf = h;
+        const field = leaf.field;
+        const value = leaf.value;
+        const op = leaf.op;
+        if ([
+            'sum',
+            'avg',
+            'count',
+            'min',
+            'max'
+        ].includes(op)) {
+            const aggrExpr = external_kysely_sql`${external_kysely_sql.raw(op.toLowerCase())}(${external_kysely_sql.ref(field)})`;
+            return external_kysely_sql`${aggrExpr} = ${external_kysely_sql.val(value)}`;
+        }
+        switch(op){
+            case 'is null':
+                return external_kysely_sql`${external_kysely_sql.ref(field)} is null`;
+            case 'is not null':
+                return external_kysely_sql`${external_kysely_sql.ref(field)} is not null`;
+            case 'in':
+                {
+                    const items = Array.isArray(value) ? value : [
+                        value
+                    ];
+                    return external_kysely_sql`${external_kysely_sql.ref(field)} in (${external_kysely_sql.join(items.map((v)=>external_kysely_sql.val(v)))})`;
+                }
+            case 'not in':
+                {
+                    const items = Array.isArray(value) ? value : [
+                        value
+                    ];
+                    return external_kysely_sql`not ${external_kysely_sql.ref(field)} in (${external_kysely_sql.join(items.map((v)=>external_kysely_sql.val(v)))})`;
+                }
+            case 'between':
+                {
+                    const [a, b] = value;
+                    return external_kysely_sql`${external_kysely_sql.ref(field)} between ${external_kysely_sql.val(a)} and ${external_kysely_sql.val(b)}`;
+                }
+            case 'not between':
+                {
+                    const [a, b] = value;
+                    return external_kysely_sql`${external_kysely_sql.ref(field)} not between ${external_kysely_sql.val(a)} and ${external_kysely_sql.val(b)}`;
+                }
+            default:
+                return external_kysely_sql`${external_kysely_sql.ref(field)} ${external_kysely_sql.raw(op)} ${external_kysely_sql.val(value)}`;
+        }
+    };
+    return toRaw(having);
+};
+const resolveHavingAliases = (having, aliasToFieldMap)=>{
+    if (!having) return having;
+    if ('op' in having && 'conditions' in having) return {
+        ...having,
+        conditions: having.conditions.map((c)=>resolveHavingAliases(c, aliasToFieldMap))
+    };
+    if ('field' in having) {
+        const resolvedField = aliasToFieldMap[having.field] || having.field;
+        return {
+            ...having,
+            field: resolvedField
+        };
+    }
+    return having;
+};
 const convertDSLToSQL = (dsl, tableName)=>{
     const db = new Kysely({
         dialect: new PostgresDialect()
@@ -165,8 +235,26 @@ const convertDSLToSQL = (dsl, tableName)=>{
     let qb = db.selectFrom(tableName);
     qb = applySelect(qb, dsl.select);
     if (dsl.where) qb = qb.where(applyWhere(dsl.where));
-    qb = applyGroupBy(qb, dsl.groupBy);
-    if (dsl.orderBy && dsl.orderBy.length > 0) for (const o of dsl.orderBy)qb = qb.orderBy(o.field, o.order ?? 'asc');
+    const aliasToFieldMap = {};
+    if (dsl.select && Array.isArray(dsl.select)) {
+        for (const item of dsl.select)if ('object' == typeof item && null !== item) {
+            const field = item.field;
+            const alias = item.alias;
+            if (alias && field) aliasToFieldMap[alias] = field;
+        }
+    }
+    let resolvedGroupBy = dsl.groupBy;
+    if (dsl.groupBy && dsl.groupBy.length > 0) resolvedGroupBy = dsl.groupBy.map((g)=>aliasToFieldMap[g] || g);
+    qb = applyGroupBy(qb, resolvedGroupBy);
+    if (dsl.having) {
+        const resolvedHaving = resolveHavingAliases(dsl.having, aliasToFieldMap);
+        qb = qb.having(applyHaving(resolvedHaving));
+    }
+    if (dsl.orderBy && dsl.orderBy.length > 0) for (const o of dsl.orderBy){
+        const fieldStr = o.field;
+        const resolvedField = aliasToFieldMap[fieldStr] || fieldStr;
+        qb = qb.orderBy(resolvedField, o.order ?? 'asc');
+    }
     qb = applyLimit(qb, dsl.limit);
     const compiled = qb.compile();
     return inlineParameters(compiled.sql, compiled.parameters);

package/dist/node/esm/sql-builder/builders/having.d.ts

@@ -0,0 +1,3 @@
+import { Having, HavingClause } from '../../types';
+import type { RawBuilder } from 'kysely';
+export declare const applyHaving: <T>(having: Having<T> | HavingClause<T>) => RawBuilder<boolean>;

package/dist/node/esm/sql-builder/builders/index.d.ts

@@ -2,3 +2,4 @@ export { applyWhere } from './where';
 export { applyGroupBy } from './groupBy';
 export { applyLimit } from './limit';
 export { applySelect } from './select';
+export { applyHaving } from './having';

package/dist/node/esm/types/dsl/Having.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Having 子句类型定义
+ * 用于聚合后的数据筛选
+ */
+export type Having<T> = HavingGroup<T>;
+export type HavingGroup<T> = {
+    op: 'and' | 'or';
+    conditions: Array<HavingClause<T>>;
+};
+export type HavingClause<T> = HavingLeaf<T> | HavingGroup<T>;
+/**
+ * Having 叶子节点
+ * 支持聚合函数操作符
+ */
+export type HavingLeaf<T> = {
+    [K in keyof T]: {
+        [O in HavingOperator]: {
+            field: K;
+            op: O;
+        } & (O extends 'is null' | 'is not null' ? {
+            value?: never;
+        } : O extends 'in' | 'not in' ? {
+            value: T[K] | T[K][];
+        } : O extends 'between' | 'not between' ? {
+            value: [T[K], T[K]];
+        } : {
+            value: T[K];
+        });
+    }[HavingOperator];
+}[keyof T];
+/**
+ * Having 操作符
+ * 聚合函数操作符
+ */
+export type HavingOperator = 'sum' | 'avg' | 'count' | 'min' | 'max' | '=' | '!=' | '>' | '>=' | '<' | '<=' | 'between' | 'not between' | 'in' | 'not in' | 'is null' | 'is not null';

package/dist/node/esm/types/dsl/QueryDSL.d.ts

@@ -2,10 +2,12 @@ import { GroupBy } from './GroupBy';
 import { OrderBy } from './OrderBy';
 import { Select } from './Select';
 import { Where } from './Where';
+import { Having } from './Having';
 export interface QueryDSL<Table> {
     select: Select<Table>;
     where?: Where<Table>;
     groupBy?: GroupBy<Table>;
+    having?: Having<Table>;
     orderBy?: OrderBy<Table>;
     limit?: number;
 }

package/dist/node/esm/types/dsl/index.d.ts

@@ -3,3 +3,4 @@ export type { GroupBy } from './GroupBy';
 export type { OrderBy } from './OrderBy';
 export type { Select } from './Select';
 export type { Where, WhereClause, WhereLeaf, WhereGroup } from './Where';
+export type { Having, HavingClause, HavingLeaf, HavingGroup, HavingOperator } from './Having';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visactor/vquery",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "type": "module",
   "exports": {
     ".": {