PostgreSQL 数据碎片整理与表空间优化的全过程

VACUUM table_name;

VACUUM FULL table_name;

autovacuum_vacuum_threshold = 50          # 触发 VACUUM 的最小死亡元组数
autovacuum_vacuum_scale_factor = 0.2      # 表大小的 20% + 50 行
autovacuum_analyze_threshold = 50
autovacuum_analyze_scale_factor = 0.1

ALTER TABLE orders SET (autovacuum_vacuum_scale_factor = 0.05);

SELECT
    schemaname,
    tablename,
    pg_size_pretty(pg_table_size(schemaname || '.' || tablename)) AS real_size,
    pg_size_pretty(pg_total_relation_size(schemaname || '.' || tablename)) AS total_size,
    n_tup_ins - n_tup_del AS net_rows,
    n_dead_tup,
    round(100.0 * n_dead_tup / GREATEST(n_live_tup + n_dead_tup, 1), 1) AS dead_pct
FROM pg_stat_user_tables
WHERE n_dead_tup > 1000
ORDER BY dead_pct DESC;

SELECT
    schemaname,
    tablename,
    indexname,
    pg_size_pretty(pg_relation_size(indexrelid)) AS index_size,
    idx_tup_read,
    idx_tup_fetch,
    CASE
        WHEN idx_tup_read = 0 THEN 'Never used'
        WHEN idx_tup_fetch = 0 THEN 'Only for scans'
        ELSE 'Active'
    END AS usage
FROM pg_stat_user_indexes
JOIN pg_index ON pg_stat_user_indexes.indexrelid = pg_index.indexrelid
WHERE pg_relation_size(indexrelid) > 10 * 1024 * 1024  -- >10MB
ORDER BY pg_relation_size(indexrelid) DESC;

CREATE EXTENSION IF NOT EXISTS pgstattuple;
SELECT * FROM pgstattuple('orders');

sudo apt-get install postgresql-14-repack

pg_repack -d your_db -t orders

-- 假设 /ssd/data 是一个高速 SSD 挂载点
CREATE TABLESPACE fast_ssd LOCATION '/ssd/data';
-- 将表创建在指定表空间
CREATE TABLE hot_orders (
    id SERIAL PRIMARY KEY,
    user_id INT,
    amount NUMERIC
) TABLESPACE fast_ssd;
-- 将现有表移动到新表空间
ALTER TABLE cold_data SET TABLESPACE slow_hdd;

SELECT
    spcname AS tablespace_name,
    pg_size_pretty(pg_tablespace_size(oid)) AS size
FROM pg_tablespace;

@Component
public class TableSpaceMigrator {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    // 每天凌晨 2 点执行
    @Scheduled(cron = "0 0 2 * * ?")
    public void migrateColdOrders() {
        String sql = """
            ALTER TABLE orders 
            SET TABLESPACE slow_hdd 
            WHERE created_at < NOW() - INTERVAL '90 days'
            """;
        // 注意：PostgreSQL 不支持 WHERE 子句的 ALTER TABLE
        // 实际应通过分区表或物化视图实现
        // 正确做法：使用分区表（见下文）
    }
}

-- 主表（分区父表）
CREATE TABLE orders (
    id SERIAL,
    order_date DATE NOT NULL,
    amount NUMERIC
) PARTITION BY RANGE (order_date);
-- 2023 年分区（放在 SSD）
CREATE TABLE orders_2023 PARTITION OF orders
FOR VALUES FROM ('2023-01-01') TO ('2024-01-01')
TABLESPACE fast_ssd;
-- 2022 年分区（放在 HDD）
CREATE TABLE orders_2022 PARTITION OF orders
FOR VALUES FROM ('2022-01-01') TO ('2023-01-01')
TABLESPACE slow_hdd;

@Entity
@Table(name = "orders")
public class Order {
    @Id
    private Long id;
    private LocalDate orderDate;
    private BigDecimal amount;
}
// Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    // 自动路由到对应分区
    List<Order> findByOrderDateBetween(LocalDate start, LocalDate end);
}

@Scheduled(cron = "0 0 1 1 * ?") // 每月 1 日
public void createNextMonthPartition() {
    LocalDate nextMonth = LocalDate.now().plusMonths(1);
    String partitionName = "orders_" + nextMonth.getYear();
    String tablespace = nextMonth.isAfter(LocalDate.now().plusMonths(6)) ? "slow_hdd" : "fast_ssd";
    String sql = String.format(
        "CREATE TABLE IF NOT EXISTS %s PARTITION OF orders " +
        "FOR VALUES FROM ('%s-01-01') TO ('%s-01-01') " +
        "TABLESPACE %s",
        partitionName,
        nextMonth.getYear(), nextMonth.plusYears(1).getYear(),
        tablespace
    );
    jdbcTemplate.execute(sql);
}

# prometheus.yml
scrape_configs:
  - job_name: 'postgres'
    static_configs:
      - targets: ['localhost:9187']

CLUSTER orders USING idx_orders_date;

EXPLAIN ANALYZE
SELECT * FROM orders WHERE order_date BETWEEN '2023-06-01' AND '2023-06-30';

-> Seq Scan on orders_2023 (...)

@Transactional
public void updateOrderStatusBatch(List<Long> ids, String status) {
    String sql = "UPDATE orders SET status = ? WHERE id = ANY(?)";
    jdbcTemplate.update(sql, status, ids.toArray());
}

String sql = """
    INSERT INTO user_stats (user_id, login_count, last_login)
    VALUES (?, 1, NOW())
    ON CONFLICT (user_id)
    DO UPDATE SET 
        login_count = user_stats.login_count + 1,
        last_login = NOW()
    """;
jdbcTemplate.update(sql, userId);

public Map<String, Object> getVacuumStats(String tableName) {
    String sql = """
        SELECT n_dead_tup, n_live_tup, last_autovacuum
        FROM pg_stat_user_tables
        WHERE relname = ?
        """;
    return jdbcTemplate.queryForMap(sql, tableName);
}

// 默认 READ COMMITTED 即可
@Transactional(isolation = Isolation.READ_COMMITTED)
public void processOrder(Long orderId) {
    // 业务逻辑
}