Hive 统计信息自动收集机制深度解析

Hive 统计信息自动收集机制深度解析

目录

1. 自动收集机制概述
2. 自动收集触发条件
3. 自动收集的内容详解
4. 元数据库存储结构
5. 元数据库查询方法
6. [自动收集 vs 手动收集](#自动收集 vs 手动收集)
7. 自动收集的限制与问题
8. 最佳实践与调优

---

自动收集机制概述

什么是自动收集？

Hive 统计信息自动收集 是指在执行某些 DML 操作（如 INSERT、LOAD 等）时，Hive 自动收集并更新表的统计信息，无需手动执行 ANALYZE TABLE 命令。

核心配置参数

# 启用自动收集统计信息
hive.stats.autogather=true

# 允许 CBO 使用列统计信息
hive.stats.fetch.column.stats=true

# 允许 CBO 使用分区统计信息
hive.stats.fetch.partition.stats=true

自动收集的工作流程

┌─────────────────────────────────────────┐
│     自动收集工作流程                     │
└─────────────────────────────────────────┘

步骤 1: 执行 DML 操作
  INSERT INTO TABLE target_table SELECT * FROM source_table;
  ↓

步骤 2: Hive 检测到 autogather=true
  → 在执行计划中添加统计信息收集任务
  ↓

步骤 3: 数据写入完成后
  → 统计信息收集任务执行
  → 计算：行数、文件数、大小等
  ↓

步骤 4: 更新元数据库
  → 将统计信息写入 Hive Metastore
  → 更新 TABLE_PARAMS 表
  ↓

步骤 5: CBO 使用统计信息
  → 后续查询可以使用这些统计信息优化

---

自动收集触发条件

会触发自动收集的操作

1. INSERT INTO / INSERT OVERWRITE

-- 会触发自动收集
INSERT INTO TABLE target_table SELECT * FROM source_table;
INSERT OVERWRITE TABLE target_table SELECT * FROM source_table;

-- 分区表也会触发
INSERT INTO TABLE partitioned_table 
PARTITION (dt='2024-01-01') 
SELECT * FROM source_table;

2. LOAD DATA

-- 会触发自动收集
LOAD DATA INPATH '/path/to/data' INTO TABLE target_table;
LOAD DATA LOCAL INPATH '/local/path' INTO TABLE target_table;

3. CREATE TABLE AS SELECT (CTAS)

-- 会触发自动收集
CREATE TABLE new_table AS SELECT * FROM source_table;

4. 动态分区插入

-- 会触发自动收集（每个分区）
INSERT OVERWRITE TABLE partitioned_table
PARTITION (dt, region)
SELECT col1, col2, dt, region FROM source_table;

不会触发自动收集的操作

✗ SELECT 查询（只读操作）
✗ ALTER TABLE（结构变更，不涉及数据）
✗ DROP TABLE（删除表）
✗ TRUNCATE TABLE（清空表，但可能清除统计信息）
✗ 直接写入 HDFS（绕过 Hive）
✗ 外部表的部分操作（取决于配置）

触发条件检查

-- 检查自动收集是否启用
SET hive.stats.autogather;

-- 查看当前配置
SHOW CONF 'hive.stats.autogather';

---

自动收集的内容详解

基本统计信息（自动收集）

收集的指标

1. numRows（行数）
   → 表中的总行数
   → 用于估算查询结果大小

2. rawDataSize（原始数据大小）
   → 未压缩的数据大小（字节）
   → 所有列的数据长度总和

3. totalSize（总大小）
   → HDFS 上实际存储大小（字节）
   → 包括压缩、block 对齐等开销

4. numFiles（文件数）
   → 表中的文件数量
   → 用于评估 I/O 成本

5. COLUMN_STATS_ACCURATE（统计信息准确性标记）
   → {"BASIC_STATS":"true"} 表示基本统计已收集

统计信息示例

查看表的统计信息：
DESCRIBE FORMATTED table_name;

输出示例：
  COLUMN_STATS_ACCURATE    | {"BASIC_STATS":"true"}
  numFiles                 | 2
  numRows                  | 30591219
  rawDataSize              | 275320971
  totalSize                | 531139857
  transient_lastDdlTime    | 1763235168

自动收集的局限性

自动收集只收集基本统计信息：
  ✓ 表级别的行数、大小、文件数
  ✗ 不收集列级别的统计信息（NDV、NULL 数量等）
  ✗ 不收集分区级别的详细统计（分区表）
  ✗ 不收集直方图统计信息

收集时机

收集时机：
  → 在数据写入完成后
  → 作为作业的最后一个任务执行
  → 如果作业失败，统计信息可能不准确或丢失

---

元数据库存储结构

Hive Metastore 数据库结构

Hive 的统计信息存储在元数据库（通常是 MySQL 或 PostgreSQL）的以下表中：

主要相关表：
  1. TBLS（表信息）
  2. TABLE_PARAMS（表参数/统计信息）
  3. PARTITIONS（分区信息）
  4. PARTITION_PARAMS（分区参数/统计信息）
  5. COLUMNS_V2（列信息）
  6. TAB_COL_STATS（表列统计信息）
  7. PART_COL_STATS（分区列统计信息）

表结构详解

1. TBLS 表

-- 表的基本信息
CREATE TABLE TBLS (
  TBL_ID BIGINT PRIMARY KEY,
  DB_ID BIGINT,                    -- 数据库 ID
  TBL_NAME VARCHAR(256),           -- 表名
  OWNER VARCHAR(767),              -- 所有者
  TBL_TYPE VARCHAR(128),           -- 表类型
  ...
);

2. TABLE_PARAMS 表

-- 存储表的参数和统计信息（键值对）
CREATE TABLE TABLE_PARAMS (
  TBL_ID BIGINT,                   -- 表 ID（外键到 TBLS）
  PARAM_KEY VARCHAR(256),          -- 参数键
  PARAM_VALUE VARCHAR(4000),       -- 参数值
  PRIMARY KEY (TBL_ID, PARAM_KEY)
);

-- 存储的统计信息键：
  'numRows'              → 行数
  'rawDataSize'          → 原始数据大小
  'totalSize'            → 总大小
  'numFiles'             → 文件数
  'COLUMN_STATS_ACCURATE' → 统计信息准确性标记
  'transient_lastDdlTime' → 最后 DDL 时间

3. PARTITIONS 表

-- 分区信息
CREATE TABLE PARTITIONS (
  PART_ID BIGINT PRIMARY KEY,
  TBL_ID BIGINT,                   -- 表 ID
  PART_NAME VARCHAR(767),          -- 分区名
  ...
);

4. PARTITION_PARAMS 表

-- 存储分区的参数和统计信息
CREATE TABLE PARTITION_PARAMS (
  PART_ID BIGINT,                  -- 分区 ID
  PARAM_KEY VARCHAR(256),          -- 参数键
  PARAM_VALUE VARCHAR(4000),       -- 参数值
  PRIMARY KEY (PART_ID, PARAM_KEY)
);

-- 存储的统计信息键（与 TABLE_PARAMS 相同）

5. TAB_COL_STATS 表

-- 表级别的列统计信息（需要手动收集）
CREATE TABLE TAB_COL_STATS (
  CS_ID BIGINT PRIMARY KEY,
  TBL_ID BIGINT,                   -- 表 ID
  COLUMN_NAME VARCHAR(767),        -- 列名
  COLUMN_TYPE VARCHAR(128),        -- 列类型
  NUM_NULLS BIGINT,                -- NULL 值数量
  NUM_DISTINCTS BIGINT,            -- 不同值数量（NDV）
  AVG_COL_LEN DOUBLE,              -- 平均列长度
  MAX_COL_LEN BIGINT,              -- 最大列长度
  NUM_TRUES BIGINT,                -- TRUE 值数量（布尔列）
  NUM_FALSES BIGINT,               -- FALSE 值数量（布尔列）
  LAST_ANALYZED BIGINT,            -- 最后分析时间
  ...
);

6. PART_COL_STATS 表

-- 分区级别的列统计信息（需要手动收集）
CREATE TABLE PART_COL_STATS (
  CS_ID BIGINT PRIMARY KEY,
  PART_ID BIGINT,                  -- 分区 ID
  COLUMN_NAME VARCHAR(767),        -- 列名
  COLUMN_TYPE VARCHAR(128),        -- 列类型
  NUM_NULLS BIGINT,                -- NULL 值数量
  NUM_DISTINCTS BIGINT,            -- 不同值数量（NDV）
  AVG_COL_LEN DOUBLE,              -- 平均列长度
  MAX_COL_LEN BIGINT,              -- 最大列长度
  LAST_ANALYZED BIGINT,            -- 最后分析时间
  ...
);

---

元数据库查询方法

查询前的准备

1. 确定元数据库类型和连接信息

# 查看 Hive 配置
cat $HIVE_HOME/conf/hive-site.xml | grep -A 5 javax.jdo.option.ConnectionURL

# 或查看 Hive 日志
grep "jdbc" $HIVE_HOME/logs/hive.log

2. 连接到元数据库

# MySQL
mysql -h <host> -u <user> -p <database_name>

# PostgreSQL
psql -h <host> -U <user> -d <database_name>

查询表的基本统计信息

方法 1: 查询 TABLE_PARAMS 表

-- 查询指定表的所有统计信息
SELECT 
    tp.PARAM_KEY,
    tp.PARAM_VALUE
FROM 
    TABLE_PARAMS tp
    JOIN TBLS t ON tp.TBL_ID = t.TBL_ID
    JOIN DBS d ON t.DB_ID = d.DB_ID
WHERE 
    d.NAME = 'your_database_name'
    AND t.TBL_NAME = 'your_table_name'
    AND tp.PARAM_KEY IN (
        'numRows',
        'rawDataSize',
        'totalSize',
        'numFiles',
        'COLUMN_STATS_ACCURATE',
        'transient_lastDdlTime'
    )
ORDER BY tp.PARAM_KEY;

方法 2: 查询所有表的统计信息

-- 查询数据库中所有表的统计信息
SELECT 
    d.NAME AS database_name,
    t.TBL_NAME AS table_name,
    MAX(CASE WHEN tp.PARAM_KEY = 'numRows' THEN tp.PARAM_VALUE END) AS num_rows,
    MAX(CASE WHEN tp.PARAM_KEY = 'rawDataSize' THEN tp.PARAM_VALUE END) AS raw_data_size,
    MAX(CASE WHEN tp.PARAM_KEY = 'totalSize' THEN tp.PARAM_VALUE END) AS total_size,
    MAX(CASE WHEN tp.PARAM_KEY = 'numFiles' THEN tp.PARAM_VALUE END) AS num_files,
    MAX(CASE WHEN tp.PARAM_KEY = 'COLUMN_STATS_ACCURATE' THEN tp.PARAM_VALUE END) AS stats_accurate,
    MAX(CASE WHEN tp.PARAM_KEY = 'transient_lastDdlTime' THEN tp.PARAM_VALUE END) AS last_ddl_time
FROM 
    TBLS t
    JOIN DBS d ON t.DB_ID = d.DB_ID
    LEFT JOIN TABLE_PARAMS tp ON t.TBL_ID = tp.TBL_ID
WHERE 
    d.NAME = 'your_database_name'
    AND tp.PARAM_KEY IN (
        'numRows',
        'rawDataSize',
        'totalSize',
        'numFiles',
        'COLUMN_STATS_ACCURATE',
        'transient_lastDdlTime'
    )
GROUP BY 
    d.NAME, t.TBL_NAME
ORDER BY 
    CAST(MAX(CASE WHEN tp.PARAM_KEY = 'numRows' THEN tp.PARAM_VALUE END) AS UNSIGNED) DESC;

方法 3: 格式化输出统计信息

-- 格式化输出，便于阅读
SELECT 
    t.TBL_NAME AS table_name,
    CONCAT(
        'Rows: ', 
        FORMAT(CAST(MAX(CASE WHEN tp.PARAM_KEY = 'numRows' THEN tp.PARAM_VALUE END) AS UNSIGNED), 0),
        ' | Files: ',
        MAX(CASE WHEN tp.PARAM_KEY = 'numFiles' THEN tp.PARAM_VALUE END),
        ' | Size: ',
        ROUND(CAST(MAX(CASE WHEN tp.PARAM_KEY = 'totalSize' THEN tp.PARAM_VALUE END) AS UNSIGNED) / 1024 / 1024, 2),
        ' MB'
    ) AS statistics
FROM 
    TBLS t
    JOIN DBS d ON t.DB_ID = d.DB_ID
    LEFT JOIN TABLE_PARAMS tp ON t.TBL_ID = tp.TBL_ID
WHERE 
    d.NAME = 'your_database_name'
    AND tp.PARAM_KEY IN ('numRows', 'numFiles', 'totalSize')
GROUP BY 
    t.TBL_NAME
ORDER BY 
    CAST(MAX(CASE WHEN tp.PARAM_KEY = 'numRows' THEN tp.PARAM_VALUE END) AS UNSIGNED) DESC;

查询分区的统计信息

查询指定表的所有分区统计信息

-- 查询分区表的统计信息
SELECT 
    p.PART_NAME AS partition_name,
    pp.PARAM_KEY AS stat_key,
    pp.PARAM_VALUE AS stat_value
FROM 
    PARTITIONS p
    JOIN TBLS t ON p.TBL_ID = t.TBL_ID
    JOIN DBS d ON t.DB_ID = d.DB_ID
    JOIN PARTITION_PARAMS pp ON p.PART_ID = pp.PART_ID
WHERE 
    d.NAME = 'your_database_name'
    AND t.TBL_NAME = 'your_partitioned_table'
    AND pp.PARAM_KEY IN (
        'numRows',
        'rawDataSize',
        'totalSize',
        'numFiles',
        'COLUMN_STATS_ACCURATE'
    )
ORDER BY 
    p.PART_NAME, pp.PARAM_KEY;

汇总分区统计信息

-- 汇总所有分区的统计信息
SELECT 
    p.PART_NAME AS partition_name,
    MAX(CASE WHEN pp.PARAM_KEY = 'numRows' THEN pp.PARAM_VALUE END) AS num_rows,
    MAX(CASE WHEN pp.PARAM_KEY = 'totalSize' THEN pp.PARAM_VALUE END) AS total_size,
    MAX(CASE WHEN pp.PARAM_KEY = 'numFiles' THEN pp.PARAM_VALUE END) AS num_files,
    MAX(CASE WHEN pp.PARAM_KEY = 'COLUMN_STATS_ACCURATE' THEN pp.PARAM_VALUE END) AS stats_accurate
FROM 
    PARTITIONS p
    JOIN TBLS t ON p.TBL_ID = t.TBL_ID
    JOIN DBS d ON t.DB_ID = d.DB_ID
    LEFT JOIN PARTITION_PARAMS pp ON p.PART_ID = pp.PART_ID
WHERE 
    d.NAME = 'your_database_name'
    AND t.TBL_NAME = 'your_partitioned_table'
GROUP BY 
    p.PART_NAME
ORDER BY 
    CAST(MAX(CASE WHEN pp.PARAM_KEY = 'numRows' THEN pp.PARAM_VALUE END) AS UNSIGNED) DESC;

查询列统计信息（手动收集的）

查询表级别的列统计

-- 查询表的列统计信息
SELECT 
    tcs.COLUMN_NAME,
    tcs.COLUMN_TYPE,
    tcs.NUM_NULLS,
    tcs.NUM_DISTINCTS AS ndv,
    tcs.AVG_COL_LEN,
    tcs.MAX_COL_LEN,
    FROM_UNIXTIME(tcs.LAST_ANALYZED) AS last_analyzed
FROM 
    TAB_COL_STATS tcs
    JOIN TBLS t ON tcs.TBL_ID = t.TBL_ID
    JOIN DBS d ON t.DB_ID = d.DB_ID
WHERE 
    d.NAME = 'your_database_name'
    AND t.TBL_NAME = 'your_table_name'
ORDER BY 
    tcs.COLUMN_NAME;

查询分区级别的列统计

-- 查询分区的列统计信息
SELECT 
    p.PART_NAME AS partition_name,
    pcs.COLUMN_NAME,
    pcs.NUM_NULLS,
    pcs.NUM_DISTINCTS AS ndv,
    pcs.AVG_COL_LEN,
    FROM_UNIXTIME(pcs.LAST_ANALYZED) AS last_analyzed
FROM 
    PART_COL_STATS pcs
    JOIN PARTITIONS p ON pcs.PART_ID = p.PART_ID
    JOIN TBLS t ON p.TBL_ID = t.TBL_ID
    JOIN DBS d ON t.DB_ID = d.DB_ID
WHERE 
    d.NAME = 'your_database_name'
    AND t.TBL_NAME = 'your_partitioned_table'
    AND pcs.COLUMN_NAME = 'your_column_name'
ORDER BY 
    p.PART_NAME;

检查统计信息是否收集

检查表是否有统计信息

-- 检查表是否有基本统计信息
SELECT 
    t.TBL_NAME,
    CASE 
        WHEN EXISTS (
            SELECT 1 FROM TABLE_PARAMS tp 
            WHERE tp.TBL_ID = t.TBL_ID 
            AND tp.PARAM_KEY = 'COLUMN_STATS_ACCURATE'
            AND tp.PARAM_VALUE LIKE '%BASIC_STATS":"true%'
        ) THEN 'YES'
        ELSE 'NO'
    END AS has_basic_stats,
    CASE 
        WHEN EXISTS (
            SELECT 1 FROM TAB_COL_STATS tcs 
            WHERE tcs.TBL_ID = t.TBL_ID
        ) THEN 'YES'
        ELSE 'NO'
    END AS has_column_stats
FROM 
    TBLS t
    JOIN DBS d ON t.DB_ID = d.DB_ID
WHERE 
    d.NAME = 'your_database_name'
ORDER BY 
    t.TBL_NAME;

检查分区是否有统计信息

-- 检查分区是否有统计信息
SELECT 
    p.PART_NAME,
    CASE 
        WHEN EXISTS (
            SELECT 1 FROM PARTITION_PARAMS pp 
            WHERE pp.PART_ID = p.PART_ID 
            AND pp.PARAM_KEY = 'COLUMN_STATS_ACCURATE'
        ) THEN 'YES'
        ELSE 'NO'
    END AS has_basic_stats,
    CASE 
        WHEN EXISTS (
            SELECT 1 FROM PART_COL_STATS pcs 
            WHERE pcs.PART_ID = p.PART_ID
        ) THEN 'YES'
        ELSE 'NO'
    END AS has_column_stats
FROM 
    PARTITIONS p
    JOIN TBLS t ON p.TBL_ID = t.TBL_ID
    JOIN DBS d ON t.DB_ID = d.DB_ID
WHERE 
    d.NAME = 'your_database_name'
    AND t.TBL_NAME = 'your_partitioned_table'
ORDER BY 
    p.PART_NAME;

统计信息完整性检查

检查统计信息是否过期

-- 检查统计信息最后更新时间
SELECT 
    t.TBL_NAME,
    FROM_UNIXTIME(
        CAST(MAX(CASE WHEN tp.PARAM_KEY = 'transient_lastDdlTime' 
            THEN tp.PARAM_VALUE END) AS UNSIGNED)
    ) AS last_ddl_time,
    DATEDIFF(
        NOW(),
        FROM_UNIXTIME(
            CAST(MAX(CASE WHEN tp.PARAM_KEY = 'transient_lastDdlTime' 
                THEN tp.PARAM_VALUE END) AS UNSIGNED)
        )
    ) AS days_since_update
FROM 
    TBLS t
    JOIN DBS d ON t.DB_ID = d.DB_ID
    LEFT JOIN TABLE_PARAMS tp ON t.TBL_ID = tp.TBL_ID
WHERE 
    d.NAME = 'your_database_name'
    AND tp.PARAM_KEY = 'transient_lastDdlTime'
GROUP BY 
    t.TBL_NAME
HAVING 
    days_since_update > 7  -- 超过 7 天未更新
ORDER BY 
    days_since_update DESC;

实用查询脚本集合

脚本 1: 完整统计信息报告

-- 生成完整的统计信息报告
SELECT 
    d.NAME AS database_name,
    t.TBL_NAME AS table_name,
    t.TBL_TYPE AS table_type,
    -- 基本统计
    MAX(CASE WHEN tp.PARAM_KEY = 'numRows' THEN tp.PARAM_VALUE END) AS num_rows,
    MAX(CASE WHEN tp.PARAM_KEY = 'numFiles' THEN tp.PARAM_VALUE END) AS num_files,
    ROUND(CAST(MAX(CASE WHEN tp.PARAM_KEY = 'totalSize' THEN tp.PARAM_VALUE END) AS UNSIGNED) / 1024 / 1024, 2) AS total_size_mb,
    ROUND(CAST(MAX(CASE WHEN tp.PARAM_KEY = 'rawDataSize' THEN tp.PARAM_VALUE END) AS UNSIGNED) / 1024 / 1024, 2) AS raw_size_mb,
    -- 统计信息状态
    MAX(CASE WHEN tp.PARAM_KEY = 'COLUMN_STATS_ACCURATE' THEN tp.PARAM_VALUE END) AS stats_accurate,
    CASE 
        WHEN EXISTS (SELECT 1 FROM TAB_COL_STATS tcs WHERE tcs.TBL_ID = t.TBL_ID) 
        THEN 'YES' 
        ELSE 'NO' 
    END AS has_column_stats,
    -- 最后更新时间
    FROM_UNIXTIME(
        CAST(MAX(CASE WHEN tp.PARAM_KEY = 'transient_lastDdlTime' 
            THEN tp.PARAM_VALUE END) AS UNSIGNED)
    ) AS last_updated
FROM 
    TBLS t
    JOIN DBS d ON t.DB_ID = d.DB_ID
    LEFT JOIN TABLE_PARAMS tp ON t.TBL_ID = tp.TBL_ID
WHERE 
    d.NAME = 'your_database_name'
GROUP BY 
    d.NAME, t.TBL_NAME, t.TBL_TYPE
ORDER BY 
    CAST(MAX(CASE WHEN tp.PARAM_KEY = 'numRows' THEN tp.PARAM_VALUE END) AS UNSIGNED) DESC;

脚本 2: 查找没有统计信息的表

-- 查找没有统计信息的表
SELECT 
    d.NAME AS database_name,
    t.TBL_NAME AS table_name
FROM 
    TBLS t
    JOIN DBS d ON t.DB_ID = d.DB_ID
WHERE 
    d.NAME = 'your_database_name'
    AND NOT EXISTS (
        SELECT 1 FROM TABLE_PARAMS tp 
        WHERE tp.TBL_ID = t.TBL_ID 
        AND tp.PARAM_KEY = 'COLUMN_STATS_ACCURATE'
    )
ORDER BY 
    t.TBL_NAME;

脚本 3: 统计信息汇总

-- 数据库级别的统计信息汇总
SELECT 
    d.NAME AS database_name,
    COUNT(DISTINCT t.TBL_ID) AS total_tables,
    COUNT(DISTINCT CASE 
        WHEN EXISTS (
            SELECT 1 FROM TABLE_PARAMS tp 
            WHERE tp.TBL_ID = t.TBL_ID 
            AND tp.PARAM_KEY = 'COLUMN_STATS_ACCURATE'
        ) THEN t.TBL_ID 
    END) AS tables_with_stats,
    SUM(CAST(MAX(CASE WHEN tp.PARAM_KEY = 'numRows' THEN tp.PARAM_VALUE END) AS UNSIGNED)) AS total_rows,
    ROUND(SUM(CAST(MAX(CASE WHEN tp.PARAM_KEY = 'totalSize' THEN tp.PARAM_VALUE END) AS UNSIGNED)) / 1024 / 1024 / 1024, 2) AS total_size_gb
FROM 
    TBLS t
    JOIN DBS d ON t.DB_ID = d.DB_ID
    LEFT JOIN TABLE_PARAMS tp ON t.TBL_ID = tp.TBL_ID
WHERE 
    d.NAME = 'your_database_name'
GROUP BY 
    d.NAME;

---

自动收集 vs 手动收集

对比表

特性	自动收集	手动收集
触发方式	自动（INSERT/LOAD 等）	手动执行 ANALYZE TABLE
收集内容	基本统计（行数、大小、文件数）	基本统计 + 列统计 + 分区统计
列统计	❌ 不收集	✅ 可收集（NDV、NULL 等）
分区统计	⚠️ 部分支持（单分区）	✅ 完整支持
直方图	❌ 不支持	✅ 支持
准确性	⚠️ 可能不准确（作业失败时）	✅ 更准确
维护成本	✅ 零成本	⚠️ 需要定期执行
适用场景	开发/测试、简单场景	生产环境、复杂查询

使用场景建议

使用自动收集的场景

✓ 开发/测试环境
✓ 简单查询场景（不需要列统计）
✓ 数据频繁插入（自动更新）
✓ 资源受限环境（减少维护成本）

使用手动收集的场景

✓ 生产环境关键表
✓ 复杂 JOIN 查询（需要列统计）
✓ 分区表查询优化（需要分区统计）
✓ 数据倾斜检测（需要 NDV）
✓ 需要精确的查询优化

---

自动收集的限制与问题

限制 1: 只收集基本统计

自动收集的内容：
  ✓ numRows（行数）
  ✓ rawDataSize（原始大小）
  ✓ totalSize（总大小）
  ✓ numFiles（文件数）

不收集的内容：
  ✗ 列统计（NDV、NULL 数量、min/max）
  ✗ 分区详细统计
  ✗ 直方图统计

限制 2: 作业失败时统计信息可能丢失

场景：
  1. INSERT 操作开始
  2. 数据写入部分完成
  3. 作业失败
  4. 统计信息可能不准确或丢失

影响：
  → 统计信息可能反映部分数据
  → CBO 可能做出错误的优化决策

限制 3: 外部表可能不支持

某些外部表场景：
  ✗ 直接写入 HDFS（绕过 Hive）
  ✗ 某些外部表格式
  ✗ 跨存储系统的表

解决方案：
  → 手动执行 ANALYZE TABLE

限制 4: 流式写入可能跳过

流式写入场景：
  → 数据持续写入
  → 统计信息收集可能被跳过
  → 或收集不完整

解决方案：
  → 定期手动收集统计信息

问题 1: 统计信息不准确

常见原因：
  1. 作业失败后统计信息未更新
  2. 并发写入导致统计信息不一致
  3. 数据删除后统计信息未更新
  4. 分区数据变化但表级别统计未更新

解决方法：
  → 定期验证统计信息
  → 数据变化后重新收集
  → 使用手动收集确保准确性

问题 2: 性能开销

自动收集的性能开销：
  → 增加作业执行时间（5-10%）
  → 额外的 MapReduce/Spark 任务
  → 元数据库写入操作

影响：
  → 对于频繁的小批量写入，开销可能较大
  → 对于大批量写入，开销相对较小

---

最佳实践与调优

配置建议

生产环境推荐配置

# 启用自动收集（基本统计）
hive.stats.autogather=true

# 允许使用列统计（需要手动收集）
hive.stats.fetch.column.stats=true

# 允许使用分区统计（需要手动收集）
hive.stats.fetch.partition.stats=true

# 统计信息收集超时（避免长时间等待）
hive.stats.collect.scanfiles=true
hive.stats.collect.partlevel=true

性能优化配置

# 并行收集统计信息
hive.stats.parallel.gather=true

# 采样收集（大数据表）
hive.stats.sampling=true
hive.stats.sampling.percent=0.1  # 10% 采样

# 快速收集（跳过某些计算）
hive.stats.fast=true

维护策略

策略 1: 自动收集 + 定期手动收集

工作流程：
  1. 启用自动收集（基本统计）
  2. 每天/每周手动收集列统计（重要表）
  3. 数据变化后重新收集
  4. 定期验证统计信息准确性

策略 2: 关键表手动收集

工作流程：
  1. 所有表启用自动收集
  2. 关键表（高频查询、大表）手动收集详细统计
  3. 分区表定期收集分区统计
  4. 监控统计信息更新时间

监控与告警

监控脚本

-- 监控统计信息收集情况
SELECT 
    d.NAME AS database_name,
    t.TBL_NAME AS table_name,
    CASE 
        WHEN EXISTS (
            SELECT 1 FROM TABLE_PARAMS tp 
            WHERE tp.TBL_ID = t.TBL_ID 
            AND tp.PARAM_KEY = 'COLUMN_STATS_ACCURATE'
        ) THEN 'YES'
        ELSE 'NO'
    END AS has_stats,
    FROM_UNIXTIME(
        CAST(MAX(CASE WHEN tp.PARAM_KEY = 'transient_lastDdlTime' 
            THEN tp.PARAM_VALUE END) AS UNSIGNED)
    ) AS last_updated
FROM 
    TBLS t
    JOIN DBS d ON t.DB_ID = d.DB_ID
    LEFT JOIN TABLE_PARAMS tp ON t.TBL_ID = tp.TBL_ID
WHERE 
    d.NAME = 'your_database_name'
GROUP BY 
    d.NAME, t.TBL_NAME
HAVING 
    has_stats = 'NO' 
    OR DATEDIFF(NOW(), last_updated) > 7
ORDER BY 
    last_updated DESC;

自动化脚本示例

自动收集统计信息脚本

#!/bin/bash
# 自动收集统计信息脚本

DATABASE="your_database"
HIVE_CMD="hive"

# 收集所有表的统计信息
$HIVE_CMD -e "
USE $DATABASE;
SHOW TABLES;
" | while read table; do
    echo "Collecting statistics for table: $table"
    $HIVE_CMD -e "
    USE $DATABASE;
    ANALYZE TABLE $table COMPUTE STATISTICS;
    "
done

# 收集列统计（重要表）
IMPORTANT_TABLES=("table1" "table2" "table3")
for table in "${IMPORTANT_TABLES[@]}"; do
    echo "Collecting column statistics for: $table"
    $HIVE_CMD -e "
    USE $DATABASE;
    ANALYZE TABLE $table COMPUTE STATISTICS FOR COLUMNS;
    "
done

---

总结

核心要点

1. 自动收集机制

   • 在 INSERT/LOAD 等操作时自动触发
   • 只收集基本统计信息（行数、大小、文件数）
   • 零维护成本，适合大多数场景

2. 元数据库查询

   • 统计信息存储在 TABLE_PARAMS 和 PARTITION_PARAMS 表
   • 列统计存储在 TAB_COL_STATS 和 PART_COL_STATS 表
   • 可以通过 SQL 直接查询和监控

3. 最佳实践

   • 生产环境：自动收集 + 定期手动收集
   • 关键表：手动收集详细统计信息
   • 定期验证和更新统计信息

4. 注意事项

   • 自动收集只收集基本统计，不收集列统计
   • 作业失败时统计信息可能不准确
   • 需要定期验证统计信息准确性

推荐配置

# 基础配置
hive.stats.autogather=true
hive.stats.fetch.column.stats=true
hive.stats.fetch.partition.stats=true

# 性能优化
hive.stats.parallel.gather=true
hive.stats.collect.scanfiles=true

---