数据格式演进史（四）：列式革命，当数据以亿行计

SELECT city, SUM(fare)
FROM trips
WHERE date = '2017-01-01'
GROUP BY city;

行式存储（像 JSON、CSV、Protobuf）：

记录1: [id=1, name="Alice", city="NYC", fare=25.00, rating=5, ...]
记录2: [id=2, name="Bob", city="LA", fare=18.50, rating=4, ...]
记录3: [id=3, name="Charlie", city="NYC", fare=32.00, rating=5, ...]
...

SELECT city, SUM(fare) FROM trips WHERE date = '2017-01-01';

读取路径：

记录1: [id, name, city✓, fare✓, rating, payment, route, ...200列] → 只用2个
记录2: [id, name, city✓, fare✓, rating, payment, route, ...200列] → 只用2个
记录3: [id, name, city✓, fare✓, rating, payment, route, ...200列] → 只用2个
× 1亿条

列式存储：

id列:     [1, 2, 3, 4, 5, ...]
name列:   ["Alice", "Bob", "Charlie", ...]
city列:   ["NYC", "LA", "NYC", ...]     ← 只读这个
fare列:   [25.00, 18.50, 32.00, ...]    ← 只读这个
rating列: [5, 4, 5, ...]
...

读取路径：

city列:  ["NYC", "LA", "NYC", ...] ← 读取
fare列:  [25.00, 18.50, 32.00, ...]  ← 读取
其他198列: 完全不碰！

city列: ["NYC", "NYC", "NYC", "LA", "LA", "NYC", "NYC", ...]

原始: NYC, NYC, NYC, LA, LA, NYC, NYC
字典: {0: "NYC", 1: "LA"}
编码: 0×3, 1×2, 0×2  → 极小！

行式存储：
  加载 record1.fare → 累加
  加载 record2.fare → 累加  ← 每次只处理1个
  加载 record3.fare → 累加

列式存储：
  加载 fare[0:8] → SIMD 一次累加8个！
  加载 fare[8:16] → SIMD 一次累加8个！

┌─────────────────────────────────────┐
│           文件元数据                 │
├─────────────────────────────────────┤
│  Row Group 1                        │
│  ├── Column Chunk: id               │
│  │   └── Page → Page → Page         │
│  ├── Column Chunk: name             │
│  │   └── Page → Page → Page         │
│  ├── Column Chunk: city             │
│  │   └── Page → Page → Page         │
│  └── ...                            │
├─────────────────────────────────────┤
│  Row Group 2                        │
│  └── ...                            │
├─────────────────────────────────────┤
│           Footer（Schema + 统计）    │
└─────────────────────────────────────┘

SELECT * FROM trips WHERE fare > 100;

Row Group 1: fare min=5, max=50     → 跳过！
Row Group 2: fare min=20, max=200   → 需要读取
Row Group 3: fare min=10, max=80    → 跳过！

import pyarrow.parquet as pq

# 写入 Parquet
df.to_parquet("trips.parquet", compression="snappy")

# 只读取需要的列
table = pq.read_table("trips.parquet", columns=["city", "fare"])

# 带谓词过滤
table = pq.read_table(
    "trips.parquet",
    columns=["city", "fare"],
    filters=[("date", "=", "2017-01-01")]
)

之前：
Pandas ──序列化──► 字节流 ──反序列化──► Spark ──序列化──► 字节流 ──反序列化──► R

之后：
Pandas ─┐
        │
Spark ──┼──► Arrow 内存格式（零拷贝共享）
        │
R ──────┘

Arrow Array（Int64 类型）：

┌────────────────────────────────────────┐
│  Validity Bitmap: [1,1,1,0,1,1,...]   │  ← 标记 NULL
├────────────────────────────────────────┤
│  Values: [10, 20, 30, ?, 50, 60, ...]  │  ← 连续内存
└────────────────────────────────────────┘
         ↑
    内存对齐，支持 SIMD

import pyarrow as pa

# Python 创建 Arrow 数组
arr = pa.array([1, 2, 3, 4, 5])

# 传给 Rust（零拷贝！）
# Rust 代码直接读取同一块内存

# 传给 R（零拷贝！）
# R 代码直接读取同一块内存

磁盘                    内存                    计算
┌─────────┐            ┌─────────┐            ┌─────────┐
│ Parquet │ ──读取──►  │  Arrow  │ ──共享──►  │ Pandas  │
│  文件   │            │  Table  │            │ Spark   │
└─────────┘            └─────────┘            │ DuckDB  │
   列式                   列式                 └─────────┘
   压缩                   原生

传输优化线：
JSON → Protobuf → FlatBuffers（零拷贝传输）

分析优化线：
CSV → Parquet（磁盘列式） + Arrow（内存列式）