1. 为什么今天的数据工程师,几乎没人再用 CSV 做核心数据存储了?
你有没有遇到过这样的场景:
凌晨两点,一个 Spark 作业还在卡在
Stage 0: 0/1 tasks
,日志里反复刷着
Reading 2.3GB file...
;
你只是想查一下
user_id
和
order_amount
两列,结果整个 50 列、800 万行的用户订单表全被拉进内存;
下游 BI 报表刷新一次要 7 分钟,而你明明只改了一个
WHERE region = '华东'
的条件;
更糟的是,业务方突然说:“上个月新增了个
coupon_code
字段,麻烦把历史数据也补上”——你打开那个 12GB 的 CSV,手开始抖。
这不是玄学,是数据格式选型的硬伤。
而 Apache Parquet,就是我过去三年在三家不同规模公司(从百人初创到千人级金融平台)落地数据中台时,
唯一一个被所有团队主动收敛、强制推行、且从未后悔过的底层存储格式
。它不是“又一个新工具”,而是对“数据如何被物理组织”这件事的一次根本性重写。
Parquet 的核心价值,从来不是“它支持列存”这个教科书定义,而是它把
数据读取行为本身,变成了可编程、可裁剪、可预测的工程动作
。
你不再需要“把整张表加载进来再过滤”,而是让存储层直接告诉你:“这一块数据里,
age
的最大值是 65,最小值是 18,所以
WHERE age > 70
这条查询,连磁盘都不用碰”。
你也不再需要为“加一列字段”而停掉整个 ETL 流水线,因为 Parquet 的元数据就躺在文件末尾,新旧文件混读毫无压力。
它甚至能让你在 S3 上用 Athena 写一条 SQL,秒级响应——而背后没有数据库、没有缓存、没有预计算,只有几千个
.parquet
文件安静地躺在桶里。
这篇文章不讲概念复读,不堆砌术语。我会带你从
物理结构拆解
开始,一层层剥开 Parquet 的设计逻辑;用
真实生产环境中的参数配置、分区策略、压缩选择
告诉你每一步“为什么这么选”;手把手还原我在某电商大促期间,如何把单次报表生成从 412 秒压到 23 秒的具体操作;最后,坦诚分享那些官方文档不会写的坑——比如为什么
snappy
在某些 SSD 上反而比
gzip
慢,为什么
partition_cols=['dt']
会比
['year','month','day']
多出 37% 的小文件,以及当 Spark 报错
Corrupted statistics in column chunk
时,真正该看哪三行日志。
如果你现在还在用 CSV 做数仓中间层,或者刚接触 Parquet 却卡在“为什么 Spark 读 Parquet 比读 CSV 快,但写却慢了一倍”的困惑里——这篇就是为你写的。它不承诺“三天成为专家”,但保证你读完后,能立刻在下一个项目里做出 有依据、可验证、不踩坑 的技术决策。
2. Parquet 的物理结构:不是“列存”两个字,而是整套数据寻址协议
很多人第一次听说 Parquet,记住的只有“列式存储”四个字。这就像只记住“汽车有四个轮子”,却不知道差速器怎么分配扭矩、ABS 如何防止抱死。Parquet 的威力,恰恰藏在它对数据物理布局的极致控制里。我们不看抽象图,直接拆一个真实文件。
2.1 用
parquet-tools
看清文件骨架
先装一个诊断工具(别跳过这步,这是你理解 Parquet 的显微镜):
# Mac 用户
brew install parquet-tools
# Linux 用户(需 Java 8+)
curl -L https://repo1.maven.org/maven2/org/apache/parquet/parquet-tools/1.13.1/parquet-tools-1.13.1.jar -o parquet-tools.jar
然后生成一个测试文件(用你最熟悉的 pandas):
import pandas as pd
import numpy as np
# 构造一个有典型特征的数据集:高基数字符串、低基数分类、数值范围大
np.random.seed(42)
df = pd.DataFrame({
"user_id": np.random.randint(1000000, 9999999, 50000),
"region": np.random.choice(["华东", "华北", "华南", "西南"], 50000),
"amount": np.random.lognormal(10, 1.5, 50000), # 对数正态分布,模拟真实交易额
"category": np.random.choice(["电子", "服装", "食品", "家居", "图书"], 50000),
"timestamp": pd.date_range("2023-01-01", periods=50000, freq="10S")
})
df.to_parquet("test_50k.parquet", engine="pyarrow", compression="snappy", index=False)
现在,用
parquet-tools
解剖它:
parquet-tools meta test_50k.parquet
输出关键部分如下(已精简,重点看标★处):
file: test_50k.parquet
creator: parquet-cpp version 1.13.1-SNAPSHOT
extra: pandas_version = 2.0.3
File schema:
message schema {
optional int64 user_id;
optional binary region (UTF8);
optional double amount;
optional binary category (UTF8);
optional int64 timestamp (TIMESTAMP_MICROS);
}
Row group 0: | Size: 1.2 MB
--------------------------------------------------------------------------------
Column 0: user_id (INT64)
Compression: SNAPPY
Encodings: RLE PLAIN_DICTIONARY
Uncompressed size: 400000 bytes
Compressed size: 215000 bytes
Statistics: min: 1000000, max: 9999999, null_count: 0 ★
Column 1: region (BYTE_ARRAY)
Compression: SNAPPY
Encodings: RLE PLAIN_DICTIONARY ★
Uncompressed size: 250000 bytes
Compressed size: 18000 bytes
Statistics: min: 华东, max: 西南, null_count: 0, distinct_count: 4 ★
Column 2: amount (DOUBLE)
Compression: SNAPPY
Encodings: PLAIN
Uncompressed size: 400000 bytes
Compressed size: 312000 bytes
Statistics: min: 12345.67, max: 9876543.21, null_count: 0 ★
...
Row group count: 1
Total row count: 50000
看到没?这里已经埋下了所有性能密码。我们逐层拆解:
2.1.1 Row Group:数据读取的最小原子单元
Parquet 不是把整张表当一个大块处理,而是切成多个
Row Group
(行组)。每个 Row Group 包含固定数量的行(默认 10,000 行,可通过
row_group_size
参数调整),并且
每个 Row Group 内部,所有列的数据是独立存储、独立压缩、独立索引的
。
提示:Row Group 是 Parquet 实现“列裁剪”和“谓词下推”的物理基础。当你执行
SELECT region, amount FROM table WHERE amount > 10000,Parquet 引擎会:
- 先扫描每个 Row Group 的
amount列统计信息(min/max);- 如果某个 Row Group 的
max(amount) <= 10000,直接跳过整个 Row Group,连磁盘都不读;- 只对可能包含目标数据的 Row Group,才去读取其
region和amount列的 Page 数据。 这就是为什么“查两列”比“查全表”快几十倍——它跳过了 90% 的 I/O。
实测对比:在 500 万行订单表中,
WHERE order_status = 'completed'
(该状态占比 12%),使用 Row Group 统计过滤后,实际读取的 Row Group 数量仅为总数的 15%,I/O 降低 85%。
2.1.2 Column Chunk:列数据的独立容器
每个 Row Group 内,每一列都对应一个
Column Chunk
(列块)。注意,
region
列的 Chunk 和
amount
列的 Chunk 完全物理隔离,存放在文件的不同偏移位置。这意味着:
-
读
region列时,磁盘头只在regionChunk 的区域来回移动,完全不触碰amountChunk; -
region列用RLE + Dictionary编码(见下文),amount列用PLAIN编码,互不影响。
这种物理隔离,是列存性能的根基。它让“只读一列”成为真正的零成本操作,而不是逻辑上的“假装只读一列”。
2.1.3 Page:内存与磁盘的缓冲桥梁
Column Chunk 还会被切分成更小的 Page (页),通常是 1MB 左右(可调)。Page 是 Parquet 的 最小压缩和编码单元 ,也是内存映射(mmap)的基本单位。
为什么需要 Page?
- 内存友好 :读取时,Parquet 可以按需将 Page 加载进内存,避免一次性加载整个 Column Chunk(可能几百 MB);
- 并发读取 :多个线程可以同时读取不同 Page,提升吞吐;
- 错误隔离 :如果某个 Page 损坏,只影响该 Page 的数据,不会导致整个 Column Chunk 不可用。
注意:Page 大小不是越大越好。我在线上曾将 Page size 从默认 1MB 改为 8MB,期望减少 Page 数量。结果发现,在随机小查询(如
SELECT * FROM t WHERE id = 12345)场景下,响应时间反而上升 40%。因为更大的 Page 意味着每次命中都要加载更多无关数据进内存。最终我们根据 P95 查询的平均返回行数,反向计算出最优 Page size 为 256KB。
2.1.4 Footer:文件的“大脑”——元数据即一切
Parquet 文件的结尾(Footer)存储了整个文件的
全局元数据
,这才是它智能的核心。
parquet-tools meta
输出里的
Statistics
、
Encodings
、
Compression
全部来自 Footer。
Footer 包含三类关键信息:
-
Schema
:精确的数据类型定义(
int64,binary (UTF8),TIMESTAMP_MICROS),比 CSV 的字符串解析可靠一万倍; -
Row Group Offsets
:每个 Row Group 在文件中的起始字节偏移,让引擎能直接
seek()到目标位置,无需顺序扫描; -
Column Statistics
:每列在每个 Row Group 中的
min/max/null_count/distinct_count。这就是谓词下推(Predicate Pushdown)的全部依据。
实操心得:很多团队忽略 Footer 的重要性,导致“明明写了
WHERE dt='2023-10-01',却还是扫全表”。根源往往是:① 数据写入时未开启统计收集(PyArrow 默认开启,pandas 需显式设置use_dictionary=True, use_deprecated_int96_timestamps=False);② 写入时row_group_size设得过大(如 100 万行),导致min/max范围太宽,无法有效过滤。我们的经验是:对于按天分区的表,row_group_size=50000是黄金值,既能保证 Row Group 数量合理,又能使min/max足够精准。
3. 核心功能深度解析:从原理到生产级配置
Parquet 的功能列表(列存、压缩、Schema Evolution)人人都会背,但真正决定项目成败的,是 每个功能背后的工程权衡 。下面我用三个最常被问、也最容易踩坑的功能,展开讲透。
3.1 压缩与编码:不是选“快”或“省”,而是选“匹配你的访问模式”
Parquet 支持多种压缩算法(Snappy, Gzip, Zstd, Brotli)和编码方式(PLAIN, RLE, DICTIONARY, DELTA)。但官方文档从不告诉你: 同一份数据,用不同组合,查询性能可能相差 5 倍 。
3.1.1 压缩算法选择:看你的瓶颈在哪
| 算法 | 压缩比 | 压缩速度 | 解压速度 | 适用场景 | 我们的生产配置 |
|---|---|---|---|---|---|
| Snappy | 2.1x | ★★★★★ | ★★★★★ | 高频查询、SSD 存储、CPU 充足 | 默认首选 |
| Zstd | 2.8x | ★★★★☆ | ★★★★☆ | 平衡压缩比与速度 | 归档层 |
| Gzip | 3.5x | ★★☆☆☆ | ★★★☆☆ | 低成本 HDD、冷数据 | 历史备份 |
| Brotli | 4.2x | ★☆☆☆☆ | ★★☆☆☆ | 极致压缩、极少访问 | 法规存档 |
关键洞察:
解压速度比压缩速度重要 10 倍
。因为数据写入是一次性的,而读取是成千上万次的。我们曾用
zstd
压缩一个 200GB 的用户画像表,节省了 62GB 存储,但所有下游报表的平均响应时间从 1.2s 升至 3.8s。最终回滚到
snappy
,并接受多花 40GB 存储——这笔账,技术负责人当场拍板。
提示:不要迷信“最新最好”。
brotli在 Parquet 中支持度仍有限(PyArrow 8.0+ 才稳定),且其高压缩比在列存场景下收益递减。我们线上 95% 的表用snappy,5% 的归档表用zstd,0% 用gzip或brotli。
3.1.2 编码方式:让数据自己“说话”
编码(Encoding)发生在压缩之前,是对原始数据的逻辑重表示,目的是让后续压缩更高效。Parquet 会为每列自动选择最优编码,但你可以干预。
-
PLAIN
:原始字节流,无变换。适合高熵数据(如
user_id,amount),压缩率一般但解码最快。 -
RLE (Run-Length Encoding)
:对连续重复值高效(如
region='华东'连续出现 1000 次)。但对随机数据无效,甚至膨胀。 -
DICTIONARY
:为字符串等低基数列建字典(
华东→0,华北→1),再用整数存储。 这是字符串列性能飞跃的关键!
实测:一个 100 万行的
region
列(仅 4 个取值),用
PLAIN
编码后大小 12MB;用
DICTIONARY
后仅 1.8MB,且查询
WHERE region='华东'
速度提升 3.2 倍(因为字典查找是 O(1))。
注意:
DICTIONARY编码有内存开销。PyArrow 默认对字符串列启用,但对binary类型需显式指定use_dictionary=True。pandas 的to_parquet()默认启用,无需额外操作。
3.1.3 生产级配置模板(PyArrow)
import pyarrow as pa
import pyarrow.parquet as pq
# 这是我们线上集群的黄金配置
table = pa.Table.from_pandas(df)
pq.write_table(
table,
"optimized.parquet",
# 核心性能参数
row_group_size=50000, # 每个 Row Group 5 万行
data_page_size=262144, # 256KB Page size
# 压缩与编码
compression="snappy",
use_dictionary=True, # 强制对字符串列启用字典编码
# 元数据控制
write_statistics=True, # 必须开启!谓词下推的基础
use_deprecated_int96_timestamps=False, # 避免时间戳精度问题
# 其他
version="2.0", # 使用 Parquet 2.0 格式(支持更优编码)
)
3.2 Schema Evolution:不是“支持”,而是“零感知演进”
Schema Evolution(模式演进)常被宣传为 Parquet 的亮点,但很多团队在真实升级时才发现: “支持”不等于“无缝” 。问题往往出在细节。
3.2.1 新增列:安全,但有陷阱
Parquet 允许向现有表添加新列,旧文件中该列为
NULL
。这很安全,但要注意:
-
Spark 的
mergeSchema=true:当读取混合新旧 Schema 的文件时,必须设置spark.read.option("mergeSchema", "true"),否则报错Cannot resolve column name。 -
Hive Metastore 的兼容性
:Hive 3.0+ 原生支持,但 Hive 2.x 需要手动
ALTER TABLE ... ADD COLUMNS,且新列在旧分区中不可见。
3.2.2 删除列:看似简单,实则危险
Parquet 不支持物理删除列 。所谓“删除”,只是在读取时忽略该列。但风险在于:
- 存储浪费 :旧文件中被“删除”的列数据依然存在,占用空间;
-
权限泄露
:如果该列含敏感信息(如
id_card),即使应用层不读,恶意用户通过parquet-tools cat仍可提取。
我们的真实案例:某金融客户要求删除
id_card列。我们没有用ALTER TABLE DROP COLUMN(Hive 不支持),而是:
- 创建新表
user_info_v2,Schema 中不含id_card;- 用 Spark 读取旧表,
SELECT * EXCEPT(id_card)写入新表;- 将新表路径替换为旧表路径(原子性
mv);- 彻底删除旧文件。整个过程耗时 3 小时,但确保了数据彻底擦除。
3.2.3 修改列类型:谨慎!谨慎!再谨慎!
INT32
→
INT64
:安全,Parquet 自动转换。
STRING
→
INT32
:
绝对禁止!
会导致读取时类型转换失败,Spark 报
Cannot cast string to int
。
正确做法:新增一列
user_id_int
,用
CAST(user_id AS BIGINT)
填充,再逐步迁移应用。
3.3 分区(Partitioning):不是“按天分”,而是“按查询模式分”
分区是 Parquet 最易被滥用的功能。“按
dt
分区”是标准答案,但如果你的查询 80% 是
WHERE user_id IN (...)
,那按
dt
分就是灾难。
3.3.1 分区键选择的黄金法则
-
高频过滤字段
:分析你最常用的
WHERE条件。如果 70% 查询带WHERE region = '华东' AND dt >= '2023-01-01',那么region/dt是最佳组合。 -
高基数慎用
:
user_id基数千万,按其分区会产生海量小文件(<1MB),严重拖慢元数据扫描。应改用bucket by user_id(Spark 支持)。 -
避免过度分区
:
year/month/day/hour四级分区,对小时级数据合理;但对日志类数据,year/month/day三级足够。我们曾见过一个团队用country/region/city/street五级分区,单个任务生成 20 万个目录,NameNode 直接 OOM。
3.3.2 生产分区实践:动态分区 + 小文件合并
# Spark 写入时自动按 dt 分区(推荐)
df.write \
.mode("append") \
.partitionBy("dt") \ # 自动创建 dt=2023-10-01/ 子目录
.option("path", "s3a://my-bucket/user_orders/") \
.format("parquet") \
.save()
# 但写入后,小文件问题必然出现。我们用 Spark 定时合并:
from pyspark.sql.functions import input_file_name
# 读取所有 dt=2023-10-01 下的文件
df_part = spark.read.parquet("s3a://my-bucket/user_orders/dt=2023-10-01/*")
# 合并为 5 个大文件(每个约 200MB)
df_part.coalesce(5).write \
.mode("overwrite") \
.option("path", "s3a://my-bucket/user_orders/dt=2023-10-01/") \
.format("parquet") \
.save()
注意:
coalesce(5)不会 shuffle,但repartition(5)会。对大表合并,优先用coalesce避免全量 shuffle。
4. 实操全流程:从本地开发到云上生产部署
理论终需落地。下面我以一个真实电商场景为例,完整走一遍 Parquet 的生产链路: 从本地 pandas 开发,到 Spark 批处理,再到云上数据湖查询 。每一步都附带可直接运行的代码和避坑指南。
4.1 场景设定:实时订单宽表构建
- 源数据 :Kafka 中的订单事件(JSON 格式),每秒 500 条;
-
目标表
:
dwd_order_detail,包含订单、用户、商品、地址四张表的关联宽表; - SLA :T+1 小时内完成当日数据入湖,支持分钟级 BI 报表;
-
存储
:AWS S3,路径
s3://my-data-lake/dwd/order_detail/; - 查询引擎 :Athena(Presto)。
4.2 步骤一:本地开发与测试(pandas + PyArrow)
这是快速验证逻辑的阶段, 绝不跳过 。很多线上问题,根源都在本地没跑通。
import pandas as pd
import pyarrow as pa
import pyarrow.parquet as pq
# 1. 模拟源数据(实际从 Kafka 消费)
raw_data = [
{"order_id": "ORD-001", "user_id": 1001, "item_id": 2001, "amount": 299.0, "dt": "2023-10-01"},
{"order_id": "ORD-002", "user_id": 1002, "item_id": 2002, "amount": 199.0, "dt": "2023-10-01"},
]
# 2. 关联维度表(模拟 join 逻辑)
users_df = pd.DataFrame({"user_id": [1001, 1002], "user_name": ["张三", "李四"], "region": ["华东", "华北"]})
items_df = pd.DataFrame({"item_id": [2001, 2002], "item_name": ["iPhone", "MacBook"], "category": ["电子", "电子"]})
# 3. 执行宽表构建(核心逻辑在此)
df = pd.DataFrame(raw_data)
df = df.merge(users_df, on="user_id", how="left")
df = df.merge(items_df, on="item_id", how="left")
df["dt"] = pd.to_datetime(df["dt"]) # 确保日期类型正确
# 4. 写入 Parquet(本地测试)
pq.write_table(
pa.Table.from_pandas(df),
"local_test.parquet",
row_group_size=10000,
compression="snappy",
write_statistics=True
)
# 5. 验证:读取并检查
test_df = pd.read_parquet("local_test.parquet")
print(test_df.dtypes) # 确认 dt 是 datetime64,不是 object
print(test_df.head())
避坑指南:
- 时间类型陷阱 :pandas 的
to_datetime()默认生成datetime64[ns],但 Parquet 2.0 推荐TIMESTAMP_MICROS。用df["dt"] = df["dt"].dt.tz_localize(None)去时区,避免 Athena 读取为BIGINT。- 空值处理 :
merge后的user_name可能为NaN。Parquet 会正确序列化为NULL,但确保你的下游系统(如 Athena)能处理NULL字符串。
4.3 步骤二:Spark 批处理(生产环境)
本地验证无误后,迁移到 Spark 集群。这是性能和稳定性的主战场。
from pyspark.sql import SparkSession
from pyspark.sql.functions import col, to_date, current_date
from pyspark.sql.types import *
# 初始化 Spark(生产配置)
spark = SparkSession.builder \
.appName("DWD_Order_Detail_Batch") \
.config("spark.sql.adaptive.enabled", "true") \
.config("spark.sql.adaptive.coalescePartitions.enabled", "true") \
.getOrCreate()
# 1. 读取源数据(假设已存为 Parquet)
raw_df = spark.read.parquet("s3a://my-data-lake/stg/orders_raw/")
# 2. 关联维度表(使用广播 Join 加速)
users_df = spark.read.parquet("s3a://my-data-lake/dim/users/").cache()
items_df = spark.read.parquet("s3a://my-data-lake/dim/items/").cache()
# 广播小表(<10MB),避免 Shuffle
wide_df = raw_df \
.join(users_df.hint("broadcast"), on="user_id", how="left") \
.join(items_df.hint("broadcast"), on="item_id", how="left") \
.withColumn("dt", to_date(col("event_time"))) # 从事件时间提取日期
# 3. 写入目标表(分区 + 优化)
wide_df \
.filter(col("dt") == current_date()) \ # 只写当日数据
.write \
.mode("append") \
.partitionBy("dt") \ # 按日期分区
.option("compression", "snappy") \
.option("parquet.block.size", "134217728") \ # 128MB Block Size
.option("parquet.page.size", "262144") \ # 256KB Page Size
.option("parquet.enable.dictionary", "true") \
.format("parquet") \
.save("s3a://my-data-lake/dwd/order_detail/")
关键配置说明:
parquet.block.size=134217728:HDFS/S3 的底层块大小,设为 128MB,确保每个 Parquet 文件至少占满一个 HDFS 块,避免跨块读取;parquet.enable.dictionary=true:强制启用字典编码,对region、category等字符串列至关重要;current_date():确保只处理当日数据,避免重跑污染历史分区。
4.4 步骤三:云上查询(Athena + Glue)
数据落库后,BI 团队通过 Athena 查询。此时,Parquet 的优势完全释放。
-- Athena 查询(无需建表,Glue 自动识别)
-- 1. 查看表结构
DESCRIBE dwd_order_detail;
-- 2. 秒级响应的聚合查询
SELECT
region,
COUNT(*) as order_cnt,
SUM(amount) as total_amount
FROM dwd_order_detail
WHERE dt = '2023-10-01' AND region IN ('华东', '华南')
GROUP BY region;
-- 3. 谓词下推生效:WHERE dt = '2023-10-01' 直接定位到 s3://.../dt=2023-10-01/ 目录
-- WHERE region = '华东' 利用 Column Statistics 跳过大量 Row Group
Athena 性能调优:
- 分区投影(Partition Projection) :对按日期分区的表,开启 Glue 的分区投影,Athena 不再扫描
SHOW PARTITIONS,而是直接计算分区路径,查询延迟降低 60%;- Workgroup 设置 :为 BI 团队创建专用 Workgroup,设置
Enforce Workgroup Configuration = true,避免用户误用UNLOAD导出全表。
5. 常见问题与实战排查技巧:那些深夜救火的真相
再完美的设计,也会在生产中遭遇意外。以下是我在过去三年中, 真实发生、真实解决、且文档里找不到答案 的五大高频问题。
5.1 问题一:
java.lang.RuntimeException: Corrupted statistics in column chunk
现象 :Spark 读取 Parquet 时随机报此错,重启任务有时好,有时坏,无法复现。
根因
:Parquet 文件 Footer 中的
min/max
统计信息损坏。常见于:
- 写入过程中进程被 kill(如 YARN Container 被抢占);
- 存储层(S3/HDFS)网络抖动导致部分 Footer 写入失败。
排查 :
# 用 parquet-tools 检查具体哪个列损坏
parquet-tools meta corrupted.parquet | grep -A 10 "Column [0-9]"
# 查看损坏列的统计
parquet-tools dump --page-header corrupted.parquet | grep -A 5 "statistics"
解决 :
-
临时方案
:Spark 中禁用统计(牺牲性能换稳定):
spark.conf.set("spark.sql.parquet.filterPushdown", "false") -
根治方案
:用
parquet-cli修复(需安装parquet-cli):# 重新生成统计信息 parquet-cli repair --in-place corrupted.parquet
5.2 问题二:Athena 查询
COUNT(*)
极慢,但
SELECT * LIMIT 10
很快
现象
:
SELECT COUNT(*) FROM t
耗时 5 分钟,而
SELECT * FROM t LIMIT 10
0.2 秒。
根因
:Athena 的
COUNT(*)
是全表扫描,但 Parquet 的
COUNT(*)
应该从 Footer 的
total_row_count
直接读取。问题在于:
Glue Catalog 没有同步 Footer 中的行数
。
验证 :
-- 查看 Glue 中的表统计
SELECT table_name, parameters['numRows'] FROM information_schema."TABLES"
WHERE table_schema = 'your_db' AND table_name = 'your_table';
如果
numRows
为空或为
-1
,即为此问题。
解决 :
- 手动更新 :在 Glue Console 中,找到表 → Actions → Update table statistics;
-
自动化
:在 Spark 写入后,调用 Glue API 更新:
import boto3 glue = boto3.client('glue') glue.update_table( DatabaseName="your_db", TableInput={ "Name": "your_table", "Parameters": {"numRows": str(wide_df.count())} } )
5.3 问题三:
pandas.read_parquet()
内存爆满,而 Spark 读取正常
现象
:一个 5GB 的 Parquet 文件,
pd.read_parquet()
启动就 OOM,Spark 读取却只占 2GB 内存。
根因 :pandas 默认将整个 Parquet 文件加载进内存,而 Spark 是 lazy evaluation,按需读取 Row Group。
解决 :
-
分块读取
(推荐):
# 按 Row Group 读取,每次只加载一个 Row Group parquet_file = pq.ParquetFile("big_file.parquet") for i in range(parquet_file.num_row_groups): row_group = parquet_file.read_row_group(i) df_chunk = row_group.to_pandas() # 处理 df_chunk -
列裁剪
:只读必要列:
df = pd.read_parquet("big_file.parquet", columns=["user_id", "amount"])
5.4 问题四:分区路径不规范,Athena 无法识别
现象
:
s3://bucket/table/dt=2023-10-01/
下有文件,但
SHOW PARTITIONS table
为空。
根因
:Athena 要求分区路径必须是
key=value
格式,且
value
不能含特殊字符。常见错误:
-
dt=2023/10/01/(含/)→ 错误; -
dt=2023-10-01 00:00:00/(含空格、冒号)→ 错误; -
dt=2023-10-01/(正确)。
解决 :
- 写入时规范 :Spark 中用 `to_date
359



被折叠的 条评论
为什么被折叠?



