PostgreSQL 聚合查询优化：ROLLUP 与 CUBE 的使用

实际应用场景分析

让我们通过一个具体的业务场景来理解这些功能的价值。

假设我们有一个电商系统的订单表 orders，包含以下字段：

CREATE TABLE orders (
    id SERIAL PRIMARY KEY,
    order_date DATE NOT NULL,
    product_category VARCHAR(50) NOT NULL,
    region VARCHAR(50) NOT NULL,
    amount DECIMAL(10,2) NOT NULL
);

我们需要生成一个多维度的销售分析报表，包含：

• 每个地区每个产品类别的销售额
• 每个地区的总销售额
• 每个产品类别的总销售额
• 所有订单的总销售额

传统方法的局限性

使用传统的 GROUP BY，我们需要分别执行多个查询：

-- 按地区和产品类别
SELECT region, product_category, SUM(amount) FROM orders GROUP BY region, product_category;

-- 按地区
SELECT region, NULL as product_category, SUM(amount) FROM orders GROUP BY region;

-- 按产品类别
SELECT NULL as region, product_category, SUM(amount) FROM orders GROUP BY product_category;

-- 总计
SELECT NULL as region, NULL as product_category, SUM(amount) FROM orders;

然后在应用层将这些结果合并。这种方法存在以下问题：

1. 多次数据库访问：需要执行 4 次查询，增加了网络开销
2. 代码复杂度高：需要在应用层处理结果合并逻辑
3. 数据一致性风险：如果在多次查询之间数据发生变化，可能导致结果不一致
4. 性能问题：重复扫描同一张表，浪费资源

使用 CUBE 的优雅解决方案

使用 CUBE，我们只需要一个查询就能获得所有需要的汇总数据：

SELECT region, product_category, SUM(amount) as total_amount 
FROM orders 
GROUP BY CUBE(region, product_category) 
ORDER BY region, product_category;

这个查询会返回所有可能的组合，包括：

• 具体的地区 + 产品类别组合
• 地区总计（product_category 为 NULL）
• 产品类别总计（region 为 NULL）
• 全局总计（两者都为 NULL）

使用 ROLLUP 的层次化方案

如果我们只需要层次化的汇总（比如先按地区，再按产品类别），可以使用 ROLLUP：

SELECT region, product_category, SUM(amount) as total_amount 
FROM orders 
GROUP BY ROLLUP(region, product_category) 
ORDER BY region, product_category;

这会生成：

• 地区 + 产品类别明细
• 每个地区的总计（product_category 为 NULL）
• 全局总计（两者都为 NULL）

注意：ROLLUP 不会生成单独的产品类别总计，因为这不符合层次结构。

理解 NULL 值的含义

在使用 ROLLUP 和 CUBE 时，结果集中会出现很多 NULL 值。这些 NULL 有两种含义：

1. 真实的 NULL 值：原始数据中该字段就是 NULL
2. 汇总占位符：表示该维度被汇总了

为了区分这两种情况，PostgreSQL 提供了 GROUPING() 函数。

GROUPING() 函数

GROUPING(column) 函数返回 0 或 1：

• 返回 0：表示该列参与了当前分组（不是汇总行）
• 返回 1：表示该列在当前行中被汇总了（是汇总占位符）

例如：

SELECT region, product_category, GROUPING(region) as region_grouped, GROUPING(product_category) as category_grouped, SUM(amount) as total_amount 
FROM orders 
GROUP BY CUBE(region, product_category);

这样我们就能清楚地知道每一行的 NULL 是真实数据还是汇总占位符。

改进的查询示例

我们可以利用 GROUPING() 函数来美化输出：

SELECT 
CASE WHEN GROUPING(region)=1 THEN '总计' ELSE COALESCE(region,'未知地区') END as region_display,
CASE WHEN GROUPING(product_category)=1 THEN '总计' ELSE COALESCE(product_category,'未知类别') END as category_display,
SUM(amount) as total_amount 
FROM orders 
GROUP BY CUBE(region, product_category) 
ORDER BY GROUPING(region), region, GROUPING(product_category), product_category;

这样输出的结果会更加用户友好，'总计'标签清晰地标识了汇总行。

性能分析与优化

虽然 ROLLUP 和 CUBE 提供了便利，但它们也可能带来性能问题，特别是当数据量很大或者维度很多时。

执行计划分析

让我们看看 PostgreSQL 如何执行这些查询。使用 EXPLAIN 命令可以查看执行计划：

EXPLAIN ANALYZE SELECT region, product_category, SUM(amount) FROM orders GROUP BY CUBE(region, product_category);

典型的执行计划可能包含：

• HashAggregate：用于计算各种分组集
• Seq Scan：全表扫描（如果没有合适的索引）

索引优化策略

为了提高性能，我们可以考虑以下索引策略：

1. 覆盖索引（Covering Index）

创建包含所有分组列和聚合列的索引：

-- 对于 CUBE(region, product_category)
CREATE INDEX idx_orders_cube_covering ON orders (region, product_category) INCLUDE (amount);

-- 对于 ROLLUP(order_date, region, product_category)
CREATE INDEX idx_orders_rollup_covering ON orders (order_date, region, product_category) INCLUDE (amount);

覆盖索引可以让 PostgreSQL 直接从索引中获取所有需要的数据，避免回表操作。

2. 部分索引（Partial Index）

如果某些维度的值分布很不均匀，可以考虑创建部分索引：

-- 只为活跃地区创建索引
CREATE INDEX idx_orders_active_regions ON orders (product_category, amount) WHERE region IN('北京','上海','广州','深圳');

3. 表达式索引

如果经常按日期的年月进行分组，可以创建表达式索引：

CREATE INDEX idx_orders_year_month ON orders (EXTRACT(YEAR FROM order_date), EXTRACT(MONTH FROM order_date));

内存和临时文件

ROLLUP 和 CUBE 查询可能会消耗大量内存，特别是当分组集很多时。PostgreSQL 使用 work_mem 参数来控制每个查询操作可以使用的内存量。

如果 work_mem 设置过小，PostgreSQL 可能会将中间结果写入临时文件，这会显著降低性能。

可以通过以下方式优化：

-- 临时增加 work_mem（仅对当前会话有效）
SET work_mem = '256MB';
-- 执行聚合查询
SELECT ... GROUP BY CUBE(...);

但要注意不要设置过大，以免影响其他并发查询。

分区表优化

对于大数据量的表，考虑使用分区表。PostgreSQL 的声明式分区可以很好地与聚合查询配合：

-- 按年份分区
CREATE TABLE orders (
    id SERIAL,
    order_date DATE NOT NULL,
    product_category VARCHAR(50),
    region VARCHAR(50),
    amount DECIMAL(10,2)
) PARTITION BY RANGE (order_date);

-- 创建年度分区
CREATE TABLE orders_2023 PARTITION OF orders FOR VALUES FROM ('2023-01-01') TO ('2024-01-01');
CREATE TABLE orders_2024 PARTITION OF orders FOR VALUES FROM ('2024-01-01') TO ('2025-01-01');

当查询只涉及特定时间范围时，PostgreSQL 可以自动排除不相关的分区，大大减少需要扫描的数据量。

Java 应用集成

现在让我们看看如何在 Java 应用中使用这些高级聚合功能。我们将使用 Spring Boot + JPA/Hibernate 作为示例框架。

项目依赖配置

首先，在 pom.xml 中添加必要的依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

实体类定义

定义 Order 实体类：

@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "order_date", nullable = false)
    private LocalDate orderDate;

    @Column(name = "product_category", nullable = false)
    private String productCategory;

    @Column(name = "region", nullable = false)
    private String region;

    @Column(name = "amount", precision = 10, scale = 2, nullable = false)
    private BigDecimal amount;

    // 构造函数、getter、setter...
    public Order() {}

    public Order(LocalDate orderDate, String productCategory, String region, BigDecimal amount) {
        this.orderDate = orderDate;
        this.productCategory = productCategory;
        this.region = region;
        this.amount = amount;
    }

    // getters and setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public LocalDate getOrderDate() { return orderDate; }
    public void setOrderDate(LocalDate orderDate) { this.orderDate = orderDate; }
    public String getProductCategory() { return productCategory; }
    public void setProductCategory(String productCategory) { this.productCategory = productCategory; }
    public String getRegion() { return region; }
    public void setRegion(String region) { this.region = region; }
    public BigDecimal getAmount() { return amount; }
    public void setAmount(BigDecimal amount) { this.amount = amount; }
}

Repository 层实现

由于 JPA/HQL 不直接支持 ROLLUP 和 CUBE，我们需要使用原生 SQL 查询。

@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    /**
     * 使用 CUBE 进行多维汇总查询
     */
    @Query(value = """
        SELECT COALESCE(region, '总计') as region, COALESCE(product_category, '总计') as product_category, 
               SUM(amount) as total_amount, GROUPING(region) as region_grouped, GROUPING(product_category) as category_grouped 
        FROM orders 
        GROUP BY CUBE(region, product_category) 
        ORDER BY region_grouped, region, category_grouped, product_category 
        """, nativeQuery = true)
    List<Object[]> findSalesSummaryWithCube();

    /**
     * 使用 ROLLUP 进行层次化汇总查询
     */
    @Query(value = """
        SELECT COALESCE(region, '总计') as region, COALESCE(product_category, '总计') as product_category, 
               SUM(amount) as total_amount, GROUPING(region) as region_grouped, GROUPING(product_category) as category_grouped 
        FROM orders 
        GROUP BY ROLLUP(region, product_category) 
        ORDER BY region_grouped, region, category_grouped, product_category 
        """, nativeQuery = true)
    List<Object[]> findSalesSummaryWithRollup();

    /**
     * 带日期范围的 CUBE 查询
     */
    @Query(value = """
        SELECT EXTRACT(YEAR FROM order_date) as year, EXTRACT(MONTH FROM order_date) as month, 
               COALESCE(region, '总计') as region, SUM(amount) as total_amount, 
               GROUPING(EXTRACT(YEAR FROM order_date)) as year_grouped, GROUPING(EXTRACT(MONTH FROM order_date)) as month_grouped, GROUPING(region) as region_grouped 
        FROM orders 
        WHERE order_date BETWEEN :startDate AND :endDate 
        GROUP BY CUBE(EXTRACT(YEAR FROM order_date), EXTRACT(MONTH FROM order_date), region) 
        ORDER BY year_grouped, year, month_grouped, month, region_grouped, region 
        """, nativeQuery = true)
    List<Object[]> findTimeBasedSalesSummary(@Param("startDate") LocalDate startDate, @Param("endDate") LocalDate endDate);
}

DTO 类定义

为了更好地处理查询结果，我们可以定义专门的 DTO 类：

public class SalesSummaryDTO {
    private String region;
    private String productCategory;
    private BigDecimal totalAmount;
    private boolean isRegionTotal;
    private boolean isCategoryTotal;

    public SalesSummaryDTO(String region, String productCategory, BigDecimal totalAmount, boolean isRegionTotal, boolean isCategoryTotal) {
        this.region = region;
        this.productCategory = productCategory;
        this.totalAmount = totalAmount;
        this.isRegionTotal = isRegionTotal;
        this.isCategoryTotal = isCategoryTotal;
    }

    // getters and setters
    public String getRegion() { return region; }
    public void setRegion(String region) { this.region = region; }
    public String getProductCategory() { return productCategory; }
    public void setProductCategory(String productCategory) { this.productCategory = productCategory; }
    public BigDecimal getTotalAmount() { return totalAmount; }
    public void setTotalAmount(BigDecimal totalAmount) { this.totalAmount = totalAmount; }
    public boolean isRegionTotal() { return isRegionTotal; }
    public void setRegionTotal(boolean regionTotal) { isRegionTotal = regionTotal; }
    public boolean isCategoryTotal() { return isCategoryTotal; }
    public void setCategoryTotal(boolean categoryTotal) { isCategoryTotal = categoryTotal; }
    public boolean isGrandTotal() { return isRegionTotal && isCategoryTotal; }
}

Service 层实现

在 Service 层中，我们将原始查询结果转换为 DTO 对象：

@Service
@Transactional(readOnly = true)
public class SalesAnalysisService {
    @Autowired
    private OrderRepository orderRepository;

    public List<SalesSummaryDTO> getSalesSummaryWithCube() {
        List<Object[]> results = orderRepository.findSalesSummaryWithCube();
        return results.stream().map(this::mapToSalesSummaryDTO).collect(Collectors.toList());
    }

    public List<SalesSummaryDTO> getSalesSummaryWithRollup() {
        List<Object[]> results = orderRepository.findSalesSummaryWithRollup();
        return results.stream().map(this::mapToSalesSummaryDTO).collect(Collectors.toList());
    }

    private SalesSummaryDTO mapToSalesSummaryDTO(Object[] row) {
        String region = (String) row[0];
        String productCategory = (String) row[1];
        BigDecimal totalAmount = (BigDecimal) row[2];
        Integer regionGrouped = ((Number) row[3]).intValue();
        Integer categoryGrouped = ((Number) row[4]).intValue();
        return new SalesSummaryDTO(region, productCategory, totalAmount, regionGrouped == 1, categoryGrouped == 1);
    }
}

Controller 层实现

最后，创建 REST API 端点：

@RestController
@RequestMapping("/api/sales")
public class SalesAnalysisController {
    @Autowired
    private SalesAnalysisService salesAnalysisService;

    @GetMapping("/summary/cube")
    public ResponseEntity<List<SalesSummaryDTO>> getSalesSummaryWithCube() {
        List<SalesSummaryDTO> summary = salesAnalysisService.getSalesSummaryWithCube();
        return ResponseEntity.ok(summary);
    }

    @GetMapping("/summary/rollup")
    public ResponseEntity<List<SalesSummaryDTO>> getSalesSummaryWithRollup() {
        List<SalesSummaryDTO> summary = salesAnalysisService.getSalesSummaryWithRollup();
        return ResponseEntity.ok(summary);
    }
}

前端展示示例

虽然本文主要关注后端实现，但值得一提的是，前端可以很容易地根据 isRegionTotal、isCategoryTotal 和 isGrandTotal() 方法来格式化显示结果。

例如，在表格中可以对总计行使用不同的样式：

// 假设这是前端 JavaScript 代码
const renderRow = (row) => {
    const isTotal = row.isRegionTotal || row.isCategoryTotal;
    const rowClass = isTotal ? 'total-row' : 'detail-row';
    return `<tr class="${rowClass}"> <td>${row.region}</td> <td>${row.productCategory}</td> <td>${row.totalAmount}</td> </tr>`;
};

高级使用技巧

除了基本的 ROLLUP 和 CUBE 用法，PostgreSQL 还提供了一些高级技巧来满足更复杂的业务需求。

混合分组集

我们可以将 ROLLUP、CUBE 和普通的 GROUP BY 组合使用：

-- 同时使用 ROLLUP 和普通分组
SELECT year, quarter, region, SUM(amount) FROM sales_data GROUP BY ROLLUP(year, quarter), region;

这会为每个 region 生成 (year, quarter) 的层次化汇总。

条件聚合与分组集结合

有时候我们需要在分组的同时进行条件聚合：

SELECT region, product_category, SUM(amount) as total_amount, 
       SUM(CASE WHEN order_date >= CURRENT_DATE - INTERVAL '30 days' THEN amount ELSE 0 END) as last_30_days_amount, COUNT(*) as order_count 
FROM orders 
GROUP BY CUBE(region, product_category);

使用窗口函数增强分析

分组集可以与窗口函数结合，提供更丰富的分析能力：

SELECT region, product_category, SUM(amount) as total_amount, 
       ROUND(SUM(amount)*100.0/SUM(SUM(amount)) OVER(), 2) as percentage_of_total 
FROM orders 
GROUP BY CUBE(region, product_category) 
ORDER BY GROUPING(region), region, GROUPING(product_category), product_category;

这个查询不仅显示了各维度的汇总金额，还计算了每个分组占总金额的百分比。

实际性能对比测试

让我们通过一个简单的性能测试来比较不同方法的效率。

测试环境设置

-- 创建测试表
CREATE TABLE test_orders AS 
SELECT generate_series(1,1000000) as id, 
       'Region'||(random()*5+1)::int as region, 
       'Category'||(random()*10+1)::int as product_category, 
       (random()*1000+10)::decimal(10,2) as amount, 
       CURRENT_DATE-(random()*365)::int as order_date;

-- 添加索引
CREATE INDEX idx_test_orders_region_category ON test_orders(region, product_category);

测试查询

方法 1：传统 UNION ALL 方式

EXPLAIN ANALYZE 
SELECT region, product_category, SUM(amount),'detail' as type FROM test_orders GROUP BY region, product_category 
UNION ALL 
SELECT region,NULL,SUM(amount),'region_total' FROM test_orders GROUP BY region 
UNION ALL 
SELECT NULL, product_category,SUM(amount),'category_total' FROM test_orders GROUP BY product_category 
UNION ALL 
SELECT NULL,NULL,SUM(amount),'grand_total' FROM test_orders;

方法 2：CUBE 方式

EXPLAIN ANALYZE SELECT region, product_category, SUM(amount) FROM test_orders GROUP BY CUBE(region, product_category);

测试结果分析

在典型的硬件配置下（8 核 CPU，16GB 内存），测试结果通常显示：

从图表可以看出，CUBE 方法在性能上有显著优势，同时保证了数据的一致性。

常见陷阱与最佳实践

在使用 ROLLUP 和 CUBE 时，需要注意一些常见的陷阱。

1. NULL 值混淆问题

如前所述，结果中的 NULL 可能代表真实数据或汇总占位符。始终使用 GROUPING() 函数来区分它们。

2. 维度爆炸问题

CUBE 的结果集大小是指数级增长的。对于 n 个维度，CUBE 会产生 2^n 个分组集。

• 2 个维度：4 个分组集 ✅
• 3 个维度：8 个分组集 ✅
• 4 个维度：16 个分组集 ⚠️
• 5 个维度：32 个分组集 ❌
• 10 个维度：1024 个分组集 🚫

建议：对于超过 4 个维度的情况，考虑使用 GROUPING SETS 来精确指定需要的分组组合，而不是使用 CUBE。

-- 只需要特定的分组组合
SELECT ... FROM sales GROUP BY GROUPING SETS ((region, product_category, year), (region, year), (product_category, year), (year), ());

3. 排序复杂性

由于结果集中包含不同粒度的数据，排序可能会变得复杂。建议在 ORDER BY 子句中使用 GROUPING() 函数来确保汇总行出现在正确的位置。

ORDER BY GROUPING(region), -- 汇总行排在后面 region, GROUPING(product_category), product_category 

4. 内存使用监控

大型 CUBE 查询可能会消耗大量内存。在生产环境中，监控查询的内存使用情况，并适当调整 work_mem 参数。

5. 索引策略

为常用的分组列创建合适的索引，特别是当表数据量很大时。覆盖索引通常能带来显著的性能提升。

与其他数据库的兼容性

虽然 ROLLUP 和 CUBE 是 SQL 标准的一部分，但不同数据库的实现可能有所差异。

PostgreSQL vs MySQL

MySQL 也支持 ROLLUP，但不支持 CUBE 和 GROUPING SETS。

-- MySQL ROLLUP (supported)
SELECT region, product_category, SUM(amount) FROM orders GROUP BY region, product_category WITH ROLLUP;

-- MySQL CUBE (not supported)
-- This will cause an error in MySQL

PostgreSQL vs SQL Server

SQL Server 完全支持 ROLLUP、CUBE 和 GROUPING SETS，语法与 PostgreSQL 基本相同。

PostgreSQL vs Oracle

Oracle 也完全支持这些功能，但在 GROUPING() 函数的使用上略有不同。

如果你的应用需要跨数据库兼容，建议：

1. 优先使用 ROLLUP：支持的数据库更多
2. 封装数据库特定的查询：在 DAO 层根据数据库类型选择不同的实现
3. 考虑使用通用的 OLAP 工具：如 Apache Druid 或 ClickHouse，它们专门为多维分析设计

更多关于 SQL 标准和不同数据库实现的信息，可以参考 SQL Standards documentation。

实际业务案例

让我们看一个真实的业务场景，展示如何在复杂的报表系统中使用这些功能。

电商销售分析仪表板

假设我们需要为电商平台构建一个销售分析仪表板，要求支持以下维度：

• 时间维度：年、季度、月
• 地理维度：国家、省份、城市
• 产品维度：类别、品牌、SKU
• 渠道维度：Web、Mobile、API

需求分析

用户希望能够：

1. 查看任意维度组合的销售数据
2. 快速切换不同的汇总级别
3. 导出完整的多维分析报表

技术方案

由于维度较多（4 个主要维度，每个维度又有多个层级），直接使用 CUBE 会导致维度爆炸（2^12 = 4096 个分组集！）。

因此，我们采用以下策略：

1. 预计算常用组合：使用物化视图存储常用的汇总数据
2. 动态查询特定组合：使用 GROUPING SETS 按需查询
3. 分层加载：先加载高层次汇总，用户展开时再加载详细数据

物化视图实现

-- 创建物化视图存储常用汇总
CREATE MATERIALIZED VIEW sales_summary_mv AS 
SELECT EXTRACT(YEAR FROM order_date) as year, region, product_category, SUM(amount) as total_amount, COUNT(*) as order_count 
FROM orders 
GROUP BY EXTRACT(YEAR FROM order_date), region, product_category;

-- 创建索引
CREATE INDEX idx_sales_summary_mv ON sales_summary_mv(year, region, product_category);

动态查询服务

@Service
public class DynamicAnalyticsService {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public List<Map<String,Object>> getDynamicSummary(List<String> dimensions, DateRange dateRange) {
        // 构建动态 GROUPING SETS 查询
        String groupingSets = buildGroupingSets(dimensions);
        String selectColumns = buildSelectColumns(dimensions);
        String sql = String.format(
            "SELECT %s, SUM(amount) as total_amount, %s FROM orders WHERE order_date BETWEEN ? AND ? GROUP BY GROUPING SETS (%s) ORDER BY %s",
            selectColumns, buildGroupingFunctions(dimensions), groupingSets, buildOrderBy(dimensions)
        );
        return jdbcTemplate.queryForList(sql, dateRange.getStart(), dateRange.getEnd());
    }

    private String buildGroupingSets(List<String> dimensions) {
        // 根据选择的维度构建分组集
        // 例如：如果选择 [year, region]，则生成 "(year, region), (year), ()"
        return dimensions.stream()
                .map(dim -> "(" + String.join(", ", dimensions.subList(0, dimensions.indexOf(dim)+1)) + ")")
                .collect(Collectors.joining(", ")) + ", ()";
    }
}

这种混合方案既保证了常用查询的高性能，又提供了灵活的动态分析能力。

未来发展趋势

随着数据分析需求的不断增长，PostgreSQL 在 OLAP（在线分析处理）方面的能力也在持续增强。

PostgreSQL 16+ 的新特性

最新的 PostgreSQL 版本引入了一些与聚合查询相关的改进：

1. 更好的并行聚合支持：ROLLUP 和 CUBE 查询现在可以更好地利用并行执行
2. 增量物化视图：减少了预计算汇总数据的维护成本
3. 向量化执行：提高了大规模数据聚合的性能

了解更多关于 PostgreSQL 在数据分析领域的应用，可以参考 PostgreSQL official documentation on aggregate functions。

总结

ROLLUP 和 CUBE 是 PostgreSQL 中非常强大的聚合查询功能，它们能够：

✅ 简化复杂报表的开发：一个查询替代多个 UNION ALL ✅ 提高查询性能：减少表扫描次数，利用优化的执行计划 ✅ 保证数据一致性：原子性地获取所有汇总级别数据 ✅ 提供灵活的分析能力：支持多维度、多层次的数据探索

在实际应用中，我们应该：

1. 根据业务需求选择合适的方法：层次化汇总用 ROLLUP，全维度分析用 CUBE
2. 注意性能优化：合理使用索引、调整内存参数、考虑分区表
3. 正确处理 NULL 值：使用 GROUPING() 函数区分真实 NULL 和汇总占位符
4. 避免维度爆炸：对于多维度场景，优先考虑 GROUPING SETS
5. 结合应用架构：在 Java 应用中合理封装这些查询，提供清晰的 API

通过合理使用这些高级聚合功能，我们可以在 PostgreSQL 中构建高效、灵活、可维护的数据分析解决方案，为企业决策提供强有力的支持。

记住，最好的查询不是最复杂的查询，而是最适合业务需求的查询。在享受 ROLLUP 和 CUBE 带来的便利的同时，也要时刻关注性能和可维护性，这样才能真正发挥 PostgreSQL 强大分析能力的价值。