# FE 启动时的元数据恢复流程
1. 加载最新的 Image 文件
2. 回放 Image 之后的 Journal 日志
3. 与其他 FE 节点同步元数据
4. 完成恢复，开始提供服务

// 传统火山模型（伪代码）
for (int i = 0; i < row_count; i++) {
    if (column_a[i] > 100) {
        result[i] = column_b[i] * 2;
    }
}

// 向量化执行（伪代码）
// 1. 批量过滤
auto filter = column_a > 100;  // SIMD 指令
// 2. 批量计算
result = column_b * 2;  // SIMD 指令
// 3. 应用过滤
result = result[filter];

-- 查看副本分布
SHOW PROC '/statistic';

-- 手动触发副本均衡
ADMIN SET FRONTEND CONFIG ("tablet_rebalancer_type" = "disk_and_tablet");
ADMIN SET FRONTEND CONFIG ("balance_load_score_threshold" = "0.1");

-- 调整 Compaction 参数
ALTER TABLE large_table SET (
    "compaction_policy" = "time_series",  -- 时序数据优化
    "time_series_compaction_goal_size_mbytes" = "1024",  -- 目标文件大小
    "time_series_compaction_file_count_threshold" = "10",  -- 文件数阈值
    "time_series_compaction_time_threshold_seconds" = "3600"  -- 时间阈值
);

-- 查看 Compaction 状态
SHOW PROC '/compactions';

-- 手动触发 Compaction
ADMIN COMPACT TABLE large_table;

-- 标记删除（逻辑删除）
DELETE FROM user_table WHERE age < 18;

-- 删除原理：
-- 1. 生成 Delete Predicate
-- 2. 查询时过滤被删除的数据
-- 3. Compaction 时物理删除

-- 快速删除整个分区
TRUNCATE TABLE sales_data PARTITION (p20240101);

-- 自动删除过期数据
ALTER TABLE logs SET (
    "storage_cooldown_time" = "2024-01-01 00:00:00"  -- 冷却时间
);

-- 动态分区自动删除
ALTER TABLE logs SET (
    "dynamic_partition.enable" = "true",
    "dynamic_partition.start" = "-7"  -- 只保留最近 7 天
);

-- 创建远程存储资源
CREATE RESOURCE "s3_resource"
PROPERTIES (
    "type" = "s3",
    "s3.endpoint" = "s3.amazonaws.com",
    "s3.region" = "us-west-2",
    "s3.bucket" = "doris-cold-data",
    "s3.access_key" = "your_access_key",
    "s3.secret_key" = "your_secret_key"
);

-- 创建冷热分层策略
CREATE STORAGE POLICY cold_storage_policy
PROPERTIES (
    "storage_resource" = "s3_resource",
    "cooldown_datetime" = "2024-01-01 00:00:00"
);

-- 应用到表
ALTER TABLE large_table SET (
    "storage_policy" = "cold_storage_policy"
);

-- Stream Load 示例
curl --location-trusted -u root: \
  -H "label:load_20240310_001" \
  -H "column_separator:," \
  -T data.csv \
  http://fe_host:8030/api/db_name/table_name/_stream_load

# 伪代码：Tablet 选择算法
def select_tablet(row, table_schema):
    # 1. 计算分区键，确定 Partition
    partition_key = row[table_schema.partition_column]
    partition = find_partition(partition_key)
    
    # 2. 计算分桶键，确定 Bucket
    bucket_key = row[table_schema.bucket_column]
    bucket_hash = hash(bucket_key)
    bucket_id = bucket_hash % table_schema.bucket_num
    
    # 3. 确定 Tablet
    tablet = partition.buckets[bucket_id]
    
    # 4. 选择 Master Replica
    master_replica = tablet.get_master_replica()
    
    return master_replica.be_node

-- 表定义
CREATE TABLE orders (
    order_id BIGINT,
    order_date DATE,
    user_id BIGINT,
    amount DECIMAL(18, 2)
)
DUPLICATE KEY(order_id)
PARTITION BY RANGE(order_date) (
    PARTITION p20240101 VALUES LESS THAN ("2024-01-02"),
    PARTITION p20240102 VALUES LESS THAN ("2024-01-03")
)
DISTRIBUTED BY HASH(user_id) BUCKETS 32;

-- 写入数据
INSERT INTO orders VALUES (1001, '2024-01-01', 12345, 99.99);

-- Tablet 选择过程：
-- 1. order_date = '2024-01-01' -> Partition p20240101
-- 2. user_id = 12345 -> hash(12345) % 32 = 17 -> Bucket 17
-- 3. 确定 Tablet: p20240101_bucket_17
-- 4. 选择 Master Replica 所在的 BE 节点

// 伪代码：Segment 写入过程
class SegmentWriter {
    void write_batch(RowBatch batch) {
        // 1. 按列拆分数据
        for (column in batch.columns) {
            // 2. 压缩列数据
            compressed_data = compress(column.data);
            
            // 3. 写入 Data Page
            write_data_page(compressed_data);
            
            // 4. 更新 ZoneMap
            update_zonemap(column.min, column.max);
            
            // 5. 更新 BloomFilter
            if (column.has_bloom_filter) {
                update_bloom_filter(column.data);
            }
        }
        
        // 6. 每 1024 行写入一个前缀索引项
        if (row_count % 1024 == 0) {
            write_short_key_index(batch.first_row);
        }
    }
    
    void close() {
        // 7. 写入索引数据
        write_indexes();
        
        // 8. 写入元数据
        write_metadata();
        
        // 9. 写入 Footer
        write_footer();
        
        // 10. Fsync 刷盘
        fsync();
    }
}

# 伪代码：Compaction Score 计算
def calculate_compaction_score(tablet):
    # Cumulative Compaction Score
    cumulative_score = tablet.cumulative_rowset_count / 5.0
    
    # Base Compaction Score
    base_score = tablet.base_rowset_count / 10.0
    
    # 访问频率加权
    access_weight = tablet.query_count / 1000.0
    
    # 最终得分
    score = (cumulative_score + base_score) * (1 + access_weight)
    
    return score

-- 示例查询
SELECT city, SUM(amount) AS total_amount
FROM orders
WHERE order_date >= '2024-01-01' AND order_date < '2024-01-02'
GROUP BY city
HAVING SUM(amount) > 10000
ORDER BY total_amount DESC
LIMIT 10;

-- 原始查询
SELECT o.order_id, u.username, o.amount
FROM orders o
JOIN users u ON o.user_id = u.user_id
WHERE o.order_date = '2024-01-01' AND u.city = 'Beijing';

-- 优化后的执行计划：
-- 1. 谓词下推：将 order_date 和 city 过滤下推到扫描层
-- 2. 列裁剪：只读取需要的列（order_id, user_id, username, amount）
-- 3. 分区裁剪：只扫描 p20240101 分区
-- 4. Join 重排序：小表（users）作为 Build 端
-- 5. Runtime Filter：从 users 表生成 user_id 的 BloomFilter，下推到 orders 表

// 伪代码：优化后的扫描过程
class OptimizedScanner {
    void scan() {
        // 1. 分区裁剪
        partitions = prune_partitions(predicates);
        
        for (partition in partitions) {
            // 2. 选择 Tablet
            tablets = partition.get_tablets();
            
            for (tablet in tablets) {
                // 3. 选择副本（负载均衡）
                replica = select_replica(tablet);
                
                // 4. 读取 Rowset（按版本）
                rowsets = tablet.get_rowsets(version);
                
                for (rowset in rowsets) {
                    // 5. 前缀索引定位
                    start_row = short_key_index.seek(predicates);
                    
                    // 6. 读取 Data Page
                    for (page in rowset.pages[start_row:]) {
                        // 7. ZoneMap 过滤
                        if (!zonemap.match(predicates)) {
                            continue;  // 跳过整个 Page
                        }
                        
                        // 8. BloomFilter 过滤
                        if (!bloom_filter.match(predicates)) {
                            continue;  // 跳过整个 Page
                        }
                        
                        // 9. 读取和解压缩
                        data = decompress(page.data);
                        
                        // 10. 列裁剪
                        data = project_columns(data, required_columns);
                        
                        // 11. 谓词过滤
                        data = filter(data, predicates);
                        
                        // 12. 返回数据
                        yield data;
                    }
                }
            }
        }
    }
}

// 传统执行（逐行处理）
for (int i = 0; i < row_count; i++) {
    if (column_a[i] > 100 && column_b[i] < 200) {
        result[i] = column_c[i] * 2;
    }
}

// 向量化执行（批量处理）
// 1. 批量过滤
auto filter1 = column_a > 100;  // SIMD 指令
auto filter2 = column_b < 200;  // SIMD 指令
auto filter = filter1 && filter2;

// 2. 批量计算
auto result = column_c * 2;  // SIMD 指令

// 3. 应用过滤
result = result[filter];

-- Range 分区（按时间）
CREATE TABLE orders (
    order_id BIGINT,
    order_date DATE,
    amount DECIMAL(18, 2)
)
PARTITION BY RANGE(order_date) (
    PARTITION p20240101 VALUES LESS THAN ("2024-01-02"),
    PARTITION p20240102 VALUES LESS THAN ("2024-01-03"),
    PARTITION p20240103 VALUES LESS THAN ("2024-01-04")
);

-- 数据分布：
-- p20240101: order_date = '2024-01-01' 的数据
-- p20240102: order_date = '2024-01-02' 的数据
-- p20240103: order_date = '2024-01-03' 的数据

-- Hash 分桶
CREATE TABLE user_orders (
    user_id BIGINT,
    order_id BIGINT,
    amount DECIMAL(18, 2)
)
DISTRIBUTED BY HASH(user_id) BUCKETS 32;

-- 数据分布：
-- Bucket 0: hash(user_id) % 32 = 0 的数据
-- Bucket 1: hash(user_id) % 32 = 1 的数据
-- ...
-- Bucket 31: hash(user_id) % 32 = 31 的数据

-- 表定义
CREATE TABLE sales_data (
    date DATE,
    product_id INT,
    amount DECIMAL(18, 2)
)
PARTITION BY RANGE(date) (
    PARTITION p20240101 VALUES LESS THAN ("2024-01-02"),
    PARTITION p20240102 VALUES LESS THAN ("2024-01-03"),
    PARTITION p20240103 VALUES LESS THAN ("2024-01-04")
)
DISTRIBUTED BY HASH(product_id) BUCKETS 16;

-- Tablet 数量计算：
-- Partition 数：3
-- Bucket 数：16
-- Tablet 总数：3 × 16 = 48

-- Tablet 列表：
-- p20240101_0, p20240101_1, ..., p20240101_15  (16 个)
-- p20240102_0, p20240102_1, ..., p20240102_15  (16 个)
-- p20240103_0, p20240103_1, ..., p20240103_15  (16 个)

-- 示例 1：无分区表
CREATE TABLE no_partition_table (
    id BIGINT,
    name VARCHAR(100)
)
DISTRIBUTED BY HASH(id) BUCKETS 32;

-- 数据分布：
-- Bucket 数：32
-- Partition 数：1（默认分区）
-- Tablet 总数：1 × 32 = 32
-- 结论：Bucket 和 Tablet 一一对应

-- Tablet 分布在多个 BE 节点：
-- BE1: Tablet_0, Tablet_8, Tablet_16, Tablet_24
-- BE2: Tablet_1, Tablet_9, Tablet_17, Tablet_25
-- BE3: Tablet_2, Tablet_10, Tablet_18, Tablet_26
-- BE4: Tablet_3, Tablet_11, Tablet_19, Tablet_27
-- ...

-- 示例 2：有分区表
CREATE TABLE partition_table (
    date DATE,
    user_id BIGINT,
    amount DECIMAL(18, 2)
)
PARTITION BY RANGE(date) (
    PARTITION p20240101 VALUES LESS THAN ("2024-01-02"),
    PARTITION p20240102 VALUES LESS THAN ("2024-01-03"),
    PARTITION p20240103 VALUES LESS THAN ("2024-01-04")
)
DISTRIBUTED BY HASH(user_id) BUCKETS 32;

-- 数据分布：
-- Bucket 数：32（每个 Partition 都有 32 个 Bucket）
-- Partition 数：3
-- Tablet 总数：3 × 32 = 96

-- 详细分布：
-- Partition p20240101:
--   ├── Bucket 0 -> Tablet p20240101_0
--   ├── Bucket 1 -> Tablet p20240101_1
--   ├── ...
--   └── Bucket 31 -> Tablet p20240101_31
--
-- Partition p20240102:
--   ├── Bucket 0 -> Tablet p20240102_0
--   ├── Bucket 1 -> Tablet p20240102_1
--   ├── ...
--   └── Bucket 31 -> Tablet p20240102_31
--
-- Partition p20240103:
--   ├── Bucket 0 -> Tablet p20240103_0
--   ├── Bucket 1 -> Tablet p20240103_1
--   ├── ...
--   └── Bucket 31 -> Tablet p20240103_31

-- Tablet 分布在多个 BE 节点（假设 4 个 BE）：
-- BE1: p20240101_0, p20240101_4, ..., p20240102_1, p20240102_5, ...
-- BE2: p20240101_1, p20240101_5, ..., p20240102_2, p20240102_6, ...
-- BE3: p20240101_2, p20240101_6, ..., p20240102_3, p20240102_7, ...
-- BE4: p20240101_3, p20240101_7, ..., p20240102_0, p20240102_4, ...

-- 写入一条数据
INSERT INTO partition_table VALUES ('2024-01-01', 12345, 99.99);

-- 数据路由过程：
-- 1. 根据 date = '2024-01-01' 确定 Partition
--    └── 命中 Partition p20240101
--
-- 2. 根据 user_id = 12345 计算 Bucket
--    ├── hash(12345) = 1234567890
--    ├── 1234567890 % 32 = 18
--    └── 确定 Bucket 18
--
-- 3. 确定 Tablet
--    └── Tablet = p20240101_18
--
-- 4. 选择 Tablet 的 Master Replica 所在的 BE 节点
--    └── 假设 p20240101_18 的 Master Replica 在 BE2
--
-- 5. 数据写入 BE2 节点
--    └── 路径：/data/doris/be/storage/data/0/10018/
--
-- 6. 同步到 Follower Replica
--    ├── BE3: Follower Replica 1
--    └── BE4: Follower Replica 2

-- 查询数据
SELECT * FROM partition_table 
WHERE date = '2024-01-01' AND user_id = 12345;

-- 查询路由过程：
-- 1. 分区裁剪：根据 date = '2024-01-01'
--    └── 只扫描 Partition p20240101（跳过其他 Partition）
--
-- 2. Bucket 裁剪：根据 user_id = 12345
--    ├── hash(12345) % 32 = 18
--    └── 只扫描 Bucket 18（跳过其他 31 个 Bucket）
--
-- 3. 确定 Tablet
--    └── 只扫描 Tablet p20240101_18
--
-- 4. 选择副本
--    └── 选择负载最低的副本（可能是 BE2、BE3 或 BE4）
--
-- 5. 扫描数据
--    └── 只扫描 1 个 Tablet，而不是全部 96 个 Tablet
--
-- 性能提升：
-- ├── 无分区裁剪：扫描 96 个 Tablet
-- ├── 有分区裁剪：扫描 32 个 Tablet（减少 67%）
-- └── 有分区 + Bucket 裁剪：扫描 1 个 Tablet（减少 99%）

-- 创建 3 副本表
CREATE TABLE important_data (
    id BIGINT,
    data VARCHAR(1000)
)
DUPLICATE KEY(id)
DISTRIBUTED BY HASH(id) BUCKETS 32
PROPERTIES (
    "replication_num" = "3"  -- 3 个副本
);

-- 副本分布：
-- Tablet 1:
--   ├── Replica 1 (Master): BE1
--   ├── Replica 2 (Follower): BE2
--   └── Replica 3 (Follower): BE3
--
-- 容错能力：可容忍 1 个 BE 节点故障

# Segment 文件示例
/data/doris/be/storage/data/0/10001/
├── 20001_0.dat    # Segment 数据文件（256MB）
├── 20001_0.idx    # Segment 索引文件（10MB）
├── 20002_0.dat    # 另一个 Segment
└── 20002_0.idx

# 文件命名规则：
# {rowset_id}_{segment_id}.dat
# 20001: Rowset ID
# 0: Segment ID（一个 Rowset 可能有多个 Segment）

-- Duplicate 模型
CREATE TABLE log_table (
    user_id BIGINT,        -- Key 列
    event_time DATETIME,   -- Key 列
    event_type VARCHAR(50),-- Value 列
    page_url VARCHAR(500)  -- Value 列
)
DUPLICATE KEY(user_id, event_time);

-- Aggregate 模型
CREATE TABLE sales_table (
    date DATE,             -- Key 列
    city VARCHAR(50),      -- Key 列
    product_id INT,        -- Key 列
    sales_amount DECIMAL(18, 2) SUM,  -- Value 列（聚合）
    order_count INT SUM    -- Value 列（聚合）
)
AGGREGATE KEY(date, city, product_id);

-- Unique 模型
CREATE TABLE user_table (
    user_id BIGINT,        -- Key 列（主键）
    username VARCHAR(100), -- Value 列
    age INT,               -- Value 列
    city VARCHAR(50)       -- Value 列
)
UNIQUE KEY(user_id);

# be.conf 配置
storage_root_path=/data1/doris,medium:SSD;/data2/doris,medium:HDD

# 存储目录结构：
/data1/doris/
├── data/           # 数据目录
│   ├── 0/          # 路径 ID
│   │   ├── 10001/  # Tablet ID
│   │   ├── 10002/
│   │   └── ...
│   └── 1/
├── meta/           # 元数据目录
└── snapshot/       # 快照目录

-- 创建表
CREATE TABLE user_behavior (
    user_id BIGINT,
    event_time DATETIME,
    event_type VARCHAR(50)
)
DUPLICATE KEY(user_id, event_time)
PARTITION BY RANGE(event_time) (
    PARTITION p20240101 VALUES LESS THAN ("2024-01-02"),
    PARTITION p20240102 VALUES LESS THAN ("2024-01-03")
)
DISTRIBUTED BY HASH(user_id) BUCKETS 16
PROPERTIES ("replication_num" = "3");

-- 数据组织：
-- Database: default_cluster:db_name
--   └── Table: user_behavior
--       ├── Partition: p20240101
--       │   ├── Bucket 0 -> Tablet 10001
--       │   │   ├── Replica 1 (BE1)
--       │   │   │   ├── Rowset 1 (Version 0-1)
--       │   │   │   │   └── Segment 1 (256MB)
--       │   │   │   │       ├── Column: user_id (Pages)
--       │   │   │   │       ├── Column: event_time (Pages)
--       │   │   │   │       ├── Column: event_type (Pages)
--       │   │   │   │       └── Indexes
--       │   │   │   └── Rowset 2 (Version 2-2)
--       │   │   ├── Replica 2 (BE2)
--       │   │   └── Replica 3 (BE3)
--       │   ├── Bucket 1 -> Tablet 10002
--       │   └── ...
--       └── Partition: p20240102
--           └── ...

-- 用户行为日志表
CREATE TABLE user_behavior_log (
    user_id BIGINT,
    event_time DATETIME,
    event_type VARCHAR(50),
    page_url VARCHAR(500),
    device_type VARCHAR(20),
    session_id VARCHAR(100)
)
DUPLICATE KEY(user_id, event_time)
COMMENT "用户行为日志表"
DISTRIBUTED BY HASH(user_id) BUCKETS 32
PROPERTIES (
    "replication_num" = "3",
    "compression" = "LZ4"
);

-- 销售汇总表
CREATE TABLE sales_summary (
    date DATE,
    city VARCHAR(50),
    product_id INT,
    sales_amount DECIMAL(18, 2) SUM,      -- 销售额求和
    order_count INT SUM,                   -- 订单数求和
    max_price DECIMAL(18, 2) MAX,         -- 最高价格
    min_price DECIMAL(18, 2) MIN,         -- 最低价格
    last_update_time DATETIME REPLACE     -- 最后更新时间（保留最新）
)
AGGREGATE KEY(date, city, product_id)
COMMENT "销售汇总表"
DISTRIBUTED BY HASH(product_id) BUCKETS 16
PROPERTIES (
    "replication_num" = "3"
);

-- 原始数据
INSERT INTO sales_summary VALUES
('2024-01-01', 'Beijing', 1001, 100.00, 1, 100.00, 100.00, '2024-01-01 10:00:00'),
('2024-01-01', 'Beijing', 1001, 200.00, 1, 200.00, 200.00, '2024-01-01 11:00:00'),
('2024-01-01', 'Beijing', 1001, 150.00, 1, 150.00, 150.00, '2024-01-01 12:00:00');

-- 存储结果（自动聚合）
-- date        | city    | product_id | sales_amount | order_count | max_price | min_price | last_update_time
-- 2024-01-01  | Beijing | 1001       | 450.00       | 3           | 200.00    | 100.00    | 2024-01-01 12:00:00

CREATE TABLE example_agg (
    -- Key 列（聚合键）
    date DATE,
    city VARCHAR(50),
    product_id INT,
    
    -- Value 列（聚合值）
    sales_amount DECIMAL(18, 2) SUM,
    order_count INT SUM
)
AGGREGATE KEY(date, city, product_id);  -- 前 3 列为 Key 列

-- 用户信息表（Merge-on-Write）
CREATE TABLE user_profile (
    user_id BIGINT,
    username VARCHAR(100),
    age INT,
    city VARCHAR(50),
    register_time DATETIME,
    last_login_time DATETIME,
    status TINYINT
)
UNIQUE KEY(user_id)
COMMENT "用户信息表"
DISTRIBUTED BY HASH(user_id) BUCKETS 32
PROPERTIES (
    "replication_num" = "3",
    "enable_unique_key_merge_on_write" = "true"  -- 开启 MoW
);

-- 插入数据
INSERT INTO user_profile VALUES
(1, 'Alice', 25, 'Beijing', '2024-01-01 10:00:00', '2024-01-01 10:00:00', 1);

-- 更新数据（相同主键）
INSERT INTO user_profile VALUES
(1, 'Alice', 26, 'Shanghai', '2024-01-01 10:00:00', '2024-01-02 10:00:00', 1);

-- 查询结果（只保留最新数据）
SELECT * FROM user_profile WHERE user_id = 1;
-- user_id | username | age | city     | register_time       | last_login_time     | status
-- 1       | Alice    | 26  | Shanghai | 2024-01-01 10:00:00 | 2024-01-02 10:00:00 | 1

-- 删除指定主键的数据
DELETE FROM user_profile WHERE user_id = 1;

-- 批量删除
DELETE FROM user_profile WHERE status = 0;

-- 只更新部分列（需要开启部分列更新）
ALTER TABLE user_profile SET ("enable_unique_key_partial_update" = "true");

-- 只更新 age 和 last_login_time
INSERT INTO user_profile (user_id, age, last_login_time) VALUES
(1, 27, '2024-01-03 10:00:00');

-- 读多写少场景（推荐 MoW）
CREATE TABLE user_dim (
    user_id BIGINT,
    ...
)
UNIQUE KEY(user_id)
PROPERTIES (
    "enable_unique_key_merge_on_write" = "true"  -- MoW
);

-- 写多读少场景（推荐 MoR）
CREATE TABLE order_status (
    order_id BIGINT,
    ...
)
UNIQUE KEY(order_id)
PROPERTIES (
    "enable_unique_key_merge_on_write" = "false"  -- MoR（默认）
);

-- ❌ 错误 1：日志表使用 Unique 模型
CREATE TABLE access_log (
    log_id BIGINT,
    ...
)
UNIQUE KEY(log_id);  -- 日志不需要去重，浪费性能

-- ✅ 正确：使用 Duplicate 模型
CREATE TABLE access_log (
    log_id BIGINT,
    ...
)
DUPLICATE KEY(log_id);

-- ❌ 错误 2：维度表使用 Duplicate 模型
CREATE TABLE user_dim (
    user_id BIGINT,
    ...
)
DUPLICATE KEY(user_id);  -- 会产生重复数据

-- ✅ 正确：使用 Unique 模型
CREATE TABLE user_dim (
    user_id BIGINT,
    ...
)
UNIQUE KEY(user_id)
PROPERTIES ("enable_unique_key_merge_on_write" = "true");

-- ❌ 错误 3：Aggregate 模型用于明细查询
CREATE TABLE order_detail (
    order_id BIGINT,
    amount DECIMAL(18, 2) SUM
)
AGGREGATE KEY(order_id);  -- 无法查询每笔订单明细

-- ✅ 正确：使用 Duplicate 模型
CREATE TABLE order_detail (
    order_id BIGINT,
    amount DECIMAL(18, 2)
)
DUPLICATE KEY(order_id);

CREATE TABLE sales_data (
    order_id BIGINT,
    order_date DATE,
    amount DECIMAL(18, 2)
)
DUPLICATE KEY(order_id)
PARTITION BY RANGE(order_date) (
    PARTITION p20240101 VALUES LESS THAN ("2024-01-02"),
    PARTITION p20240102 VALUES LESS THAN ("2024-01-03"),
    PARTITION p20240103 VALUES LESS THAN ("2024-01-04")
)
DISTRIBUTED BY HASH(order_id) BUCKETS 16;

-- 自动创建和删除分区
ALTER TABLE sales_data SET (
    "dynamic_partition.enable" = "true",
    "dynamic_partition.time_unit" = "DAY",
    "dynamic_partition.start" = "-7",        -- 保留最近 7 天
    "dynamic_partition.end" = "3",           -- 提前创建未来 3 天
    "dynamic_partition.prefix" = "p",
    "dynamic_partition.buckets" = "16"
);

-- 查询时自动裁剪分区
SELECT * FROM sales_data
WHERE order_date >= '2024-01-01' AND order_date < '2024-01-03';
-- 只扫描 p20240101 和 p20240102 两个分区

-- 分桶数量建议
-- 1. 单个 Tablet 大小控制在 1GB - 10GB
-- 2. 分桶数 = 数据量 / 单 Tablet 大小
-- 3. 分桶数建议为 BE 节点数的倍数

-- 示例：100GB 数据，期望单 Tablet 5GB
-- 分桶数 = 100GB / 5GB = 20

CREATE TABLE large_table (
    id BIGINT,
    data VARCHAR(1000)
)
DUPLICATE KEY(id)
DISTRIBUTED BY HASH(id) BUCKETS 20;  -- 20 个分桶

-- 创建 Colocate Group
CREATE TABLE fact_table (
    user_id BIGINT,
    amount DECIMAL(18, 2)
)
DISTRIBUTED BY HASH(user_id) BUCKETS 32
PROPERTIES (
    "colocate_with" = "user_group"
);

CREATE TABLE dim_table (
    user_id BIGINT,
    username VARCHAR(100)
)
DISTRIBUTED BY HASH(user_id) BUCKETS 32
PROPERTIES (
    "colocate_with" = "user_group"  -- 与 fact_table 在同一 Group
);

-- Join 时无需 Shuffle
SELECT f.user_id, d.username, f.amount
FROM fact_table f
JOIN dim_table d ON f.user_id = d.user_id;

-- 建表时指定压缩算法
CREATE TABLE compressed_table (
    id BIGINT,
    data VARCHAR(1000)
)
DUPLICATE KEY(id)
DISTRIBUTED BY HASH(id) BUCKETS 16
PROPERTIES (
    "compression" = "ZSTD"  -- 使用 ZSTD 压缩
);

-- 修改压缩算法
ALTER TABLE compressed_table SET ("compression" = "LZ4");

-- ❌ 错误：日志表使用 Unique 模型
CREATE TABLE access_log (
    log_id BIGINT,
    user_id BIGINT,
    access_time DATETIME
)
UNIQUE KEY(log_id)  -- 日志不需要去重，浪费性能
DISTRIBUTED BY HASH(log_id) BUCKETS 32;

-- ✅ 正确：使用 Duplicate 模型
CREATE TABLE access_log (
    log_id BIGINT,
    user_id BIGINT,
    access_time DATETIME
)
DUPLICATE KEY(log_id, user_id)
DISTRIBUTED BY HASH(user_id) BUCKETS 32;

-- ❌ 错误：低频列在前
CREATE TABLE sales_data (
    product_id INT,      -- 低频过滤
    region VARCHAR(50),  -- 低频过滤
    date DATE,           -- 高频过滤
    amount DECIMAL(18, 2)
)
DUPLICATE KEY(product_id, region, date)
DISTRIBUTED BY HASH(product_id) BUCKETS 16;

-- ✅ 正确：高频列在前
CREATE TABLE sales_data (
    date DATE,           -- 高频过滤（按天查询）
    region VARCHAR(50),  -- 中频过滤（按地区查询）
    product_id INT,      -- 低频过滤
    amount DECIMAL(18, 2)
)
DUPLICATE KEY(date, region, product_id)
DISTRIBUTED BY HASH(date) BUCKETS 16;

-- Key 列字节计算
CREATE TABLE user_table (
    user_id BIGINT,        -- 8 字节
    username VARCHAR(20),  -- 20 字节
    email VARCHAR(50),     -- 50 字节（超出 36 字节）
    age INT                -- 4 字节
)
DUPLICATE KEY(user_id, username, email)
DISTRIBUTED BY HASH(user_id) BUCKETS 32;

-- 前缀索引只覆盖：user_id (8) + username (20) + email 的前 8 字节
-- email 的后 42 字节不在索引中，过滤效果差

-- ✅ 推荐：自动管理分区
CREATE TABLE order_data (
    order_id BIGINT,
    order_date DATE,
    amount DECIMAL(18, 2)
)
DUPLICATE KEY(order_id)
PARTITION BY RANGE(order_date) ()  -- 空分区列表
DISTRIBUTED BY HASH(order_id) BUCKETS 16
PROPERTIES (
    "dynamic_partition.enable" = "true",
    "dynamic_partition.time_unit" = "DAY",
    "dynamic_partition.start" = "-30",      -- 保留最近 30 天
    "dynamic_partition.end" = "3",          -- 提前创建未来 3 天
    "dynamic_partition.prefix" = "p",
    "dynamic_partition.buckets" = "16",
    "dynamic_partition.create_history_partition" = "true"
);

-- ❌ 错误：分区过细（按小时分区）
PARTITION BY RANGE(order_time) (
    PARTITION p2024010100 VALUES LESS THAN ("2024-01-01 01:00:00"),
    PARTITION p2024010101 VALUES LESS THAN ("2024-01-01 02:00:00"),
    ...  -- 每天 24 个分区，管理复杂
)

-- ✅ 正确：按天分区
PARTITION BY RANGE(order_date) (
    PARTITION p20240101 VALUES LESS THAN ("2024-01-02"),
    PARTITION p20240102 VALUES LESS THAN ("2024-01-03")
)

-- ❌ 错误：低基数列作为分桶键
CREATE TABLE user_orders (
    user_id BIGINT,
    gender VARCHAR(10),  -- 只有 2 个值（男/女）
    order_id BIGINT
)
DUPLICATE KEY(user_id)
DISTRIBUTED BY HASH(gender) BUCKETS 32;  -- 数据严重倾斜

-- ✅ 正确：高基数列作为分桶键
CREATE TABLE user_orders (
    user_id BIGINT,
    gender VARCHAR(10),
    order_id BIGINT
)
DUPLICATE KEY(user_id)
DISTRIBUTED BY HASH(user_id) BUCKETS 32;  -- 数据均匀分布

-- 注意：分桶数创建后无法修改，只能重建表
-- 建议：初期预留一定余量

-- 当前数据量 100GB，预期增长到 500GB
-- 分桶数 = 500GB / 5GB = 100
CREATE TABLE growth_table (
    id BIGINT,
    data VARCHAR(1000)
)
DUPLICATE KEY(id)
DISTRIBUTED BY HASH(id) BUCKETS 100;  -- 预留增长空间

-- 生产环境推荐配置
CREATE TABLE production_table (
    id BIGINT,
    data VARCHAR(1000)
)
DUPLICATE KEY(id)
DISTRIBUTED BY HASH(id) BUCKETS 32
PROPERTIES (
    "replication_num" = "3",              -- 3 副本
    "replication_allocation" = "tag.location.default: 3"
);

CREATE TABLE user_behavior (
    user_id BIGINT,              -- 用户ID，范围大
    age TINYINT,                 -- 年龄，0-120 足够
    login_count INT,             -- 登录次数
    is_vip BOOLEAN,              -- 是否VIP，0/1
    status TINYINT,              -- 状态码：0-待审核 1-正常 2-冻结
    total_amount LARGEINT        -- 累计金额（分），超大数值
)
DUPLICATE KEY(user_id)
DISTRIBUTED BY HASH(user_id) BUCKETS 32;

-- DECIMAL(P, S)：P=总位数，S=小数位数
-- 存储空间根据精度自动选择：
-- P ≤ 9：4字节
-- 9 < P ≤ 18：8字节
-- 18 < P ≤ 38：16字节
-- 38 < P ≤ 76：32字节（需开启 enable_decimal256=true）

CREATE TABLE financial_data (
    order_id BIGINT,
    price DECIMAL(18, 2),        -- 价格：最多16位整数+2位小数
    discount DECIMAL(5, 4),      -- 折扣：0.0000 ~ 9.9999
    total_amount DECIMAL(20, 2), -- 总金额：支持更大范围
    tax_rate DECIMAL(6, 4),      -- 税率：0.0000 ~ 99.9999
    latitude DOUBLE,             -- 纬度：高精度浮点
    longitude DOUBLE             -- 经度：高精度浮点
)
DUPLICATE KEY(order_id)
DISTRIBUTED BY HASH(order_id) BUCKETS 32;

CREATE TABLE order_log (
    order_id BIGINT,
    user_id BIGINT,
    order_date DATE,                    -- 订单日期（按天统计）
    create_time DATETIME,               -- 创建时间（精确到秒）
    update_time DATETIME(6),            -- 更新时间（精确到微秒）
    payment_time DATETIME               -- 支付时间
)
DUPLICATE KEY(order_id, user_id)
PARTITION BY RANGE(order_date) (
    PARTITION p202401 VALUES LESS THAN ("2024-02-01"),
    PARTITION p202402 VALUES LESS THAN ("2024-03-01")
)
DISTRIBUTED BY HASH(order_id) BUCKETS 32;

-- 日期计算
SELECT 
    order_date,
    DATE_ADD(order_date, INTERVAL 7 DAY) AS delivery_date,
    DATEDIFF(NOW(), order_date) AS days_ago,
    DATE_FORMAT(create_time, '%Y-%m-%d %H:%i:%s') AS formatted_time
FROM order_log;

-- 时间戳转换
SELECT 
    FROM_UNIXTIME(1609459200) AS datetime_value,
    UNIX_TIMESTAMP('2024-01-01 00:00:00') AS timestamp_value;

CREATE TABLE product_info (
    product_id BIGINT,
    product_code CHAR(10),              -- 固定长度产品编码
    product_name VARCHAR(200),          -- 产品名称
    short_desc VARCHAR(500),            -- 简短描述
    detail_desc STRING,                 -- 详细描述（可能很长）
    tags VARCHAR(1000),                 -- 标签列表
    json_data STRING,                   -- JSON 数据
    country_code CHAR(2)                -- 国家代码：CN, US
)
DUPLICATE KEY(product_id)
DISTRIBUTED BY HASH(product_id) BUCKETS 32;

-- ✅ 正确：根据实际需求设置合理长度
CREATE TABLE user_profile (
    username VARCHAR(50),       -- 用户名：通常不超过50字符
    email VARCHAR(100),         -- 邮箱：标准长度
    phone VARCHAR(20),          -- 手机号：国际格式
    address VARCHAR(500),       -- 地址：中等长度
    bio STRING                  -- 个人简介：可能很长
)
DUPLICATE KEY(username)
DISTRIBUTED BY HASH(username) BUCKETS 32;

-- ❌ 错误：长度设置不合理
CREATE TABLE bad_example (
    username VARCHAR(10000),    -- 过长，浪费空间
    phone VARCHAR(5),           -- 过短，无法存储完整号码
    email STRING                -- 不必要的超长类型
)
DUPLICATE KEY(username)
DISTRIBUTED BY HASH(username) BUCKETS 32;

CREATE TABLE user_tags (
    user_id BIGINT,
    tags ARRAY<VARCHAR(50)>,            -- 标签数组
    scores ARRAY<INT>,                  -- 分数数组
    login_times ARRAY<DATETIME>         -- 登录时间数组
)
DUPLICATE KEY(user_id)
DISTRIBUTED BY HASH(user_id) BUCKETS 32;

-- 查询数组
SELECT 
    user_id,
    tags,
    ARRAY_SIZE(tags) AS tag_count,
    tags[1] AS first_tag,                -- 数组下标从1开始
    ARRAY_CONTAINS(tags, '活跃用户') AS is_active
FROM user_tags
WHERE ARRAY_SIZE(tags) > 0;

-- 展开数组
SELECT 
    user_id,
    tag
FROM user_tags
LATERAL VIEW EXPLODE(tags) tmp AS tag;

CREATE TABLE product_attributes (
    product_id BIGINT,
    attributes MAP<VARCHAR(50), VARCHAR(200)>,  -- 属性映射
    prices MAP<VARCHAR(20), DECIMAL(10,2)>      -- 不同地区价格
)
DUPLICATE KEY(product_id)
DISTRIBUTED BY HASH(product_id) BUCKETS 32;

-- 查询 MAP
SELECT 
    product_id,
    attributes,
    attributes['brand'] AS brand,
    attributes['color'] AS color,
    MAP_SIZE(attributes) AS attr_count,
    MAP_KEYS(attributes) AS all_keys,
    MAP_VALUES(attributes) AS all_values
FROM product_attributes;

CREATE TABLE order_detail (
    order_id BIGINT,
    shipping_info STRUCT<
        address: VARCHAR(500),
        city: VARCHAR(50),
        province: VARCHAR(50),
        zipcode: VARCHAR(20),
        phone: VARCHAR(20)
    >,
    receiver STRUCT<
        name: VARCHAR(50),
        phone: VARCHAR(20)
    >
)
DUPLICATE KEY(order_id)
DISTRIBUTED BY HASH(order_id) BUCKETS 32;

-- 查询 STRUCT
SELECT 
    order_id,
    shipping_info.address,
    shipping_info.city,
    receiver.name
FROM order_detail;

CREATE TABLE event_log (
    event_id BIGINT,
    event_time DATETIME,
    event_data JSON                     -- JSON 数据
)
DUPLICATE KEY(event_id)
DISTRIBUTED BY HASH(event_id) BUCKETS 32;

-- 查询 JSON
SELECT 
    event_id,
    JSON_EXTRACT(event_data, '$.user_id') AS user_id,
    JSON_EXTRACT(event_data, '$.action') AS action,
    JSON_EXTRACT(event_data, '$.properties.page') AS page
FROM event_log
WHERE JSON_EXTRACT(event_data, '$.action') = 'click';

-- 创建 BITMAP 聚合表
CREATE TABLE user_visit_bitmap (
    visit_date DATE,
    page_id INT,
    user_ids BITMAP BITMAP_UNION       -- BITMAP 类型，聚合方式为 BITMAP_UNION
)
AGGREGATE KEY(visit_date, page_id)
DISTRIBUTED BY HASH(page_id) BUCKETS 32;

-- 导入数据
INSERT INTO user_visit_bitmap 
SELECT 
    visit_date,
    page_id,
    BITMAP_HASH(user_id) AS user_ids
FROM user_visit_log
GROUP BY visit_date, page_id;

-- 查询 UV
SELECT 
    visit_date,
    page_id,
    BITMAP_UNION_COUNT(user_ids) AS uv
FROM user_visit_bitmap
GROUP BY visit_date, page_id;

-- 交集、并集计算
SELECT 
    BITMAP_INTERSECT_COUNT(user_ids) AS common_users,
    BITMAP_UNION_COUNT(user_ids) AS total_users
FROM user_visit_bitmap
WHERE visit_date BETWEEN '2024-01-01' AND '2024-01-07';

-- 创建 HLL 聚合表
CREATE TABLE page_uv_hll (
    visit_date DATE,
    page_id INT,
    user_hll HLL HLL_UNION             -- HLL 类型，聚合方式为 HLL_UNION
)
AGGREGATE KEY(visit_date, page_id)
DISTRIBUTED BY HASH(page_id) BUCKETS 32;

-- 导入数据
INSERT INTO page_uv_hll 
SELECT 
    visit_date,
    page_id,
    HLL_HASH(user_id) AS user_hll
FROM user_visit_log
GROUP BY visit_date, page_id;

-- 查询近似 UV
SELECT 
    visit_date,
    SUM(HLL_UNION_AGG(user_hll)) AS total_uv
FROM page_uv_hll
GROUP BY visit_date;

-- 创建分位数聚合表
CREATE TABLE response_time_quantile (
    service_name VARCHAR(100),
    log_date DATE,
    response_time_state QUANTILE_STATE QUANTILE_UNION
)
AGGREGATE KEY(service_name, log_date)
DISTRIBUTED BY HASH(service_name) BUCKETS 32;

-- 导入数据
INSERT INTO response_time_quantile 
SELECT 
    service_name,
    log_date,
    TO_QUANTILE_STATE(response_time, 2048) AS response_time_state
FROM service_log
GROUP BY service_name, log_date;

-- 查询 P50、P95、P99
SELECT 
    service_name,
    log_date,
    QUANTILE_PERCENT(QUANTILE_UNION(response_time_state), 0.5) AS p50,
    QUANTILE_PERCENT(QUANTILE_UNION(response_time_state), 0.95) AS p95,
    QUANTILE_PERCENT(QUANTILE_UNION(response_time_state), 0.99) AS p99
FROM response_time_quantile
GROUP BY service_name, log_date;

CREATE TABLE access_log (
    log_id BIGINT,
    client_ipv4 IPv4,                   -- IPv4 地址
    client_ipv6 IPv6,                   -- IPv6 地址
    access_time DATETIME
)
DUPLICATE KEY(log_id)
DISTRIBUTED BY HASH(log_id) BUCKETS 32;

-- IP 函数使用
SELECT 
    client_ipv4,
    IPv4NumToString(client_ipv4) AS ip_string,
    IPv4StringToNum('192.168.1.1') AS ip_num,
    IPv4CIDRToRange(IPv4StringToNum('192.168.1.0'), 24) AS ip_range
FROM access_log;

-- 数值类型自动提升
SELECT 
    TINYINT_col + INT_col,              -- 结果为 INT
    INT_col + BIGINT_col,               -- 结果为 BIGINT
    FLOAT_col + DOUBLE_col,             -- 结果为 DOUBLE
    INT_col + DECIMAL_col;              -- 结果为 DECIMAL

-- 字符串与数值转换
SELECT 
    '123' + 456,                        -- 字符串转数值：579
    CONCAT(123, '456');                 -- 数值转字符串：'123456'

-- CAST 函数
SELECT 
    CAST('123' AS INT),                 -- 字符串转整数
    CAST(123.45 AS INT),                -- 浮点转整数：123
    CAST(123 AS VARCHAR),               -- 整数转字符串
    CAST('2024-01-01' AS DATE),         -- 字符串转日期
    CAST(NOW() AS DATE);                -- 时间戳转日期

-- 类型转换注意事项
SELECT 
    CAST('abc' AS INT),                 -- 转换失败返回 NULL
    CAST(9999999999999999999 AS INT);   -- 溢出返回 NULL

-- ❌ 错误：滥用 VARCHAR
CREATE TABLE bad_table (
    user_id VARCHAR(50),      -- 应该用 BIGINT
    age VARCHAR(10),          -- 应该用 INT
    is_active VARCHAR(10),    -- 应该用 TINYINT
    create_time VARCHAR(50)   -- 应该用 DATETIME
)
DUPLICATE KEY(user_id)
DISTRIBUTED BY HASH(user_id) BUCKETS 32;

-- ✅ 正确：使用合适的类型
CREATE TABLE good_table (
    user_id BIGINT,
    age INT,
    is_active TINYINT,        -- 0/1
    create_time DATETIME
)
DUPLICATE KEY(user_id)
DISTRIBUTED BY HASH(user_id) BUCKETS 32;

-- 根据实际数据长度设置，避免浪费
CREATE TABLE user_info (
    username VARCHAR(50),     -- 用户名最长 50 字符
    email VARCHAR(100),       -- 邮箱最长 100 字符
    address VARCHAR(500),     -- 地址最长 500 字符
    description TEXT          -- 超长文本用 TEXT
)
DUPLICATE KEY(username)
DISTRIBUTED BY HASH(username) BUCKETS 32;

-- 建表时创建索引
CREATE TABLE product_table (
    product_id BIGINT,
    product_name VARCHAR(200),
    description TEXT,
    category VARCHAR(50),
    price DECIMAL(18, 2),
    INDEX idx_name (product_name) USING INVERTED,      -- 倒排索引
    INDEX idx_desc (description) USING INVERTED,       -- 全文检索
    INDEX idx_category (category) USING BITMAP         -- Bitmap 索引
)
DUPLICATE KEY(product_id)
DISTRIBUTED BY HASH(product_id) BUCKETS 32;

CREATE TABLE optimized_table (
    id BIGINT,
    data VARCHAR(1000)
)
DUPLICATE KEY(id)
DISTRIBUTED BY HASH(id) BUCKETS 32
PROPERTIES (
    -- 副本配置
    "replication_num" = "3",
    
    -- 压缩配置
    "compression" = "LZ4",
    
    -- 存储介质（冷热分层）
    "storage_medium" = "SSD",
    "storage_cooldown_time" = "2024-12-31 23:59:59",  -- 冷却时间
    
    -- Bloom Filter
    "bloom_filter_columns" = "id",  -- 为 id 列创建 BloomFilter
    
    -- Unique Key 模式
    "enable_unique_key_merge_on_write" = "true",
    
    -- 数据导入
    "in_memory" = "false",  -- 是否常驻内存
    
    -- Compaction 配置
    "compaction_policy" = "time_series"  -- 时序数据优化
);

-- 事实表
CREATE TABLE fact_orders (
    user_id BIGINT,
    order_id BIGINT,
    amount DECIMAL(18, 2)
)
DUPLICATE KEY(user_id, order_id)
DISTRIBUTED BY HASH(user_id) BUCKETS 32
PROPERTIES (
    "colocate_with" = "user_group",
    "replication_num" = "3"
);

-- 维度表
CREATE TABLE dim_users (
    user_id BIGINT,
    username VARCHAR(100),
    city VARCHAR(50)
)
DUPLICATE KEY(user_id)
DISTRIBUTED BY HASH(user_id) BUCKETS 32  -- 必须相同
PROPERTIES (
    "colocate_with" = "user_group",  -- 必须相同
    "replication_num" = "3"
);

-- 1. 查看表结构
SHOW CREATE TABLE table_name;

-- 2. 查看分区信息
SHOW PARTITIONS FROM table_name;

-- 3. 查看 Tablet 分布
SHOW TABLETS FROM table_name;

-- 4. 查看表统计信息
SHOW DATA FROM table_name;

-- 5. 查看索引信息
SHOW INDEX FROM table_name;

-- 导入测试数据
INSERT INTO table_name VALUES (...);

-- 执行典型查询，查看执行计划
EXPLAIN SELECT * FROM table_name WHERE ...;

-- 查看查询性能
SELECT * FROM table_name WHERE ... LIMIT 100;

-- 基础创建
CREATE DATABASE db_name;

-- 指定字符集
CREATE DATABASE db_name
DEFAULT CHARACTER SET utf8mb4
DEFAULT COLLATE utf8mb4_general_ci;

-- 如果不存在则创建
CREATE DATABASE IF NOT EXISTS db_name;

-- 添加注释
CREATE DATABASE db_name COMMENT '业务数据库';