JSON Toolkit

jq และไฟล์ JSON ขนาดใหญ่: ทำไม -s จึงทำให้หน่วยความจำระเบิด และวิธีประมวลผลแบบสตรีม

สรุปสำคัญ: การรวม log JSON หลายร้อย MB ด้วย jq -s จบลงด้วย OOM ขณะที่ reduce inputs สร้างสถิติเดียวกันด้วย RAM เพียงไม่กี่ MB วัดจากตัวอย่าง 220 MB และ 2 ล้านบรรทัด: slurp พีคที่ 2,08 GB เทียบกับ 3,5 MB ของตัวรวมแบบสตรีม บทความนี้อธิบายกลไกการกินหน่วยความจำ การประมวลผล JSONL ทีละบรรทัด เหตุการณ์พาธของ --stream และกับดักจริงสามข้อ รวมถึงผลลัพธ์ว่างเงียบ ๆ ของ -n --stream

ขั้นสูงอ่านประมาณ 6 นาทีเผยแพร่ 2026-11-12อัปเดต 2026-11-12
เปรียบเทียบหน่วยความจำระหว่าง jq streaming กับ -s บน JSON ขนาดใหญ่

jq parse เร็ว แต่แทบทุกกรณีที่ตายเมื่อเจอไฟล์สักสองสามร้อย MB ย้อนกลับไปที่ flag เดียวกัน: -s โหลดอินพุตทั้งหมดเข้าอาร์เรย์ยักษ์อันเดียว และ RSS พีคทะลุหลายเท่าของขนาดไฟล์ได้ง่าย ๆ

ไฟล์เดียว สองคำสั่ง: หน่วยความจำน้อยลง 580 เท่า

เริ่มจากการวัดจริง ตัวอย่างคือ log JSONL ขนาด 220 MB จำนวน 2,000,000 บรรทัด (บรรทัดละหนึ่งรายการ request: timestamp, level, path, status, duration_ms, uid) สภาพแวดล้อม: jq 1.7 บน Linux x86_64 วัด RSS พีคด้วย /usr/bin/time -v:

คำสั่ง งาน เวลา RSS พีค
jq -s 'group_by(.level) | ...' นับตาม level 10,1s 2,08 GB (~9,5 เท่าของไฟล์)
jq -n 'reduce inputs ...' นับแบบเดียวกัน 4,7s 3,5 MB
jq -r 'select(...) | .path' กรองทีละบรรทัด 2,6s 3,6 MB

สถิติเดียวกัน หน่วยความจำน้อยลง 580 เท่า แถมเร็วกว่า นี่ไม่ใช่บั๊กของ jq — -s ตามนิยามคือ «อ่านทุกอย่างเข้าอาร์เรย์»; คนส่วนใหญ่แค่ไม่ได้คิดค่าเริ่มต้นนี้เลย แหล่งภายนอกก็ตรงกัน: รายงานจากชุมชน Huawei Cloud เรื่อง JSONL 2,3 GB เล่าเรื่องเดียวกันเป๊ะ — OOM กับ slurp แล้วตัวรวมแบบสตรีมจบใน 47 วินาทีที่ RSS แค่ 30 MB กว่า ๆ Dratini.tech วัดบนอินพุต 2,5 GB เห็น jq -s ถูก OOM killer ฆ่ากระทั่งบนเครื่อง RAM 16 GB+ ขณะที่ไปป์ไลน์ปกติจบใน 48,2s ที่ 84 MB

ข้อสรุปก่อนอื่น: ถ้าไฟล์เกินครึ่งหนึ่งของหน่วยความจำที่มี -s ไม่คือตัวเลือกตั้งแต่แรก วัดสามอย่างก่อนเขียนอะไร: ls -lh ดูขนาด free -m ดูหน่วยความจำคงเหลือ wc -l ดูจำนวนบรรทัด

หน่วยความจำหายไปทางไหนกันแน่

jq -s (slurp) ถูกจดไว้ว่า «อ่านอินพุตทั้งหมดเข้าอาร์เรย์» ต้นทุนจริงทะลุข้อความไปมาก: หลัง parse แล้ว jq ถือโครงสร้าง C เป็นต้นไม้ และทุก object, array, string, number ต่างพอตโหนดของตัวเองพร้อม metadata ข้อความ 220 MB ของเรากลายเป็นโครงสร้างเกิน 2 GB ขึ้นไป — บวมราว 9,5 เท่า group_by ยังเรียงและจับกลุ่มในหน่วยความจำซ้ำ ขยายพีคออกไปอีก

เอกสาร JSON ใหญ่ชิ้นเดียวก็พฤติกรรมเดียวกัน ห่ม log เดิมเข้าอาร์เรย์ราก 300 MB แล้วดึงด้วย filter ปกติ:

คำสั่ง เวลา RSS พีค
jq '.[] | select(.level=="ERROR") | .uid' (ทั้งเอกสาร) 4,7s 1,85 GB
jq --stream 'select(...)' (เหตุการณ์พาธ) 13,4s 3,4 MB

การ parse ทั้งก้อนยังพีคราว 1,8 GB — jq สร้างต้นไม้ทั้งหมดก่อน filter จะทำงาน --stream แลกเวลารันประมาณ 3 เท่ากับหน่วยความจำเล็กลง 540 เท่า โมเดลละเอียดของการบวมนี้พัฒนาต่อได้ที่ หน่วยความจำมาจากไหน

Log JSONL: การอ่านทีละบรรทัดเป็นสตรีมอยู่แล้ว

ถ้า «ไฟล์ใหญ่» ของคุณแท้จริงคือ JSONL — object ละหนึ่งบรรทัด — พฤติกรรมเริ่มต้นของ jq เป็นสตรีมอยู่แล้ว: ทุกบรรทัดถูก parse และปล่อยออกอย่างอิสระ และ -s ไม่ใช่แค่ไม่จำเป็นแต่เป็นโทษด้วย:

# นับตาม level: ทีละบรรทัด รวมในเชลล์
jq -r '.level' app.jsonl | sort | uniq -c | sort -rn | head

# กรอง + ดึงค่า: select ก่อน บรรทัดที่ไม่ตรงทิ้งทันที
jq -r 'select(.level=="ERROR") | .path' app.jsonl | sort | uniq -c | sort -rn | head -5

สองนิสัยที่ควรฝึกให้เป็น:

  • select ไว้หัวไปป์ไลน์สุด ๆ jq กรองทันทีที่บรรทัดถูก parse กรองหลังการแปลงคือเปลืองการคำนวณ
  • -r สำหรับสตริงดิบ ไม่งั้นผลลัพธ์คือสตริง JSON มีเครื่องหมายคำพูด และ uniq -c จะนับ "ERROR" กับ ERROR เป็นคนละค่ากัน

สำหรับบรรทัดพัง ใช้ fromjson?: jq -r 'fromjson? | .level' ข้ามบรรทัดที่ parse ไม่ได้แบบเงียบ ๆ และชิ้นส่วนที่ถูกตัดขาดไม่ทำให้ไปป์ไลน์ทั้งเส้นตาย ตัวรูปแบบเองมีอยู่ใน คู่มือปฏิบัติ JSONL บทนี้ว่าด้วยคำสั่งที่ประมวลผลมัน

การรวมทั้งชุด: reduce inputs รักษาสถานะให้จำกัด

การกรองทีละบรรทัดเป็นหน้าที่ของเชลล์ แต่เมื่อต้องรวมภายใน jq เอง — ตัวนับตาม level เวลาเฉลี่ยตาม path — กุญแจคือ reduce กับ inputs เพื่อสถานะที่จำกัด:

# นับตาม level: หน่วยความจำตามขนาดผลลัพธ์ ไม่ใช่ขนาดไฟล์
jq -n 'reduce inputs as $x ({}; .[$x.level] = ((.[$x.level] // 0) + 1))' app.jsonl

# เวลาเฉลี่ยตาม path: สถานะคือคู่คงที่ {count, total}
jq -n 'reduce inputs as $x ({}; .[$x.path].count += 1 | .[$x.path].total += $x.duration_ms)
      | map_values(.total / .count)' app.jsonl

สองรายละเอียด:

  • -n หมายความว่า jq ต้องไม่กินอินพุตแรกเป็นค่าเริ่มต้น inputs เป็นผู้ปล่อยรายการเอง ลืม -n แล้วรายการแรกจะถูกกลืนเป็นสถานะเริ่มต้นไปเลย
  • สถานะของตัวรวมต้องมีรูปทรงคงที่ — มีแต่ตัวนับกับตัวสะสม พอคุณเหวี่ยงบรรทัดที่ตรงเข้าอาร์เรย์ในตัวรวม หน่วยความจำกลับไปวิ่งตามปริมาณข้อมูล และสตรีมก็ไร้ค่าทันที

จึงเป็นที่มาของ 3,5 MB ในตาราง: สองกิกะไบต์ไหลผ่าน เหลือแค่ตารางแฮช

เอกสารใหญ่ชิ้นเดียว: เหตุการณ์พาธของ --stream

เมื่ออินพุตเป็นเอกสารรากยักษ์เพียงชิ้นเดียว (export สองสามร้อย MB ไม่มีเส้นแบ่งบรรทัด) ให้ใช้ --stream แทนที่จะปล่อยค่าเต็ม มันปล่อยลำดับเหตุการณ์ «พาธ + ค่าใบ»:

# เหตุการณ์หนึ่งดูเหมือน: อาร์เรย์พาธ + สเกลาร์
$ echo '{"rows":[{"id":"a"},{"id":"b"}],"meta":{"id":"top"}}' | jq -c --stream .
["rows",0,"id"]
"a"
["rows",1,"id"]
"b"
["meta","id"]
"top"

การดึงจากสตรีมเหตุการณ์ต้องแมตช์ รูปร่างพาธเต็ม — ความลึก ชื่อสมาชิก ตำแหน่งดัชนี — เพราะเช็คแค่ปลายสุดจะจอดคีย์ชื่อซ้ำใน object ที่ซ้อนอยู่ด้วย:

# เฉพาะ rows[i].id ละเว้น meta.id และญาติชื่อเดียวกันที่ลึกกว่า
jq --stream 'select(length == 2 and .[0][0] == "rows" and .[0][-1] == "id") | .[1]' huge.json

การรวมยังคงเป็น reduce inputs รูปทรงคงที่ (กับ -n --stream ต้องกินเหตุการณ์ผ่าน inputs — ดูกับดัก) ส่วนการประกอบกลับ — เปลี่ยนสตรีมเหตุการณ์กลับเป็น object เต็ม — ใช้ truncate_stream คู่กับ fromstream ภาพรวมการเลือกเครื่องมือตามขนาดอยู่ที่ ไฟล์ JSON ใหญ่เกินไป?

กับดักจริงสามข้อ

กับดักหนึ่ง: -n --stream ไม่มี inputs ไม่ปล่อยอะไรเลย แบบเงียบ ๆ พบบนเครื่องนี้เอง: jq -n --stream 'select(...)' file.json จบด้วยโค้ด 0 ไม่มีผลลัพธ์ไม่มี error — ในโหมด -n jq ไม่อ่านอินพุต และ select ของฟิลเตอร์ไม่ได้รับเหตุการณ์เลยสักอัน ที่ถูก: ถอด -n ออกแล้วใช้ --stream เปล่า ๆ หรือจับคู่ -n --stream กับ reduce inputs ครอบครัวความพัง «สำเร็จแต่ว่าง» แบบนี้ดีบั๊กยากที่สุด ตรวจกับตัวอย่างเล็กก่อนมัดรวมเป็นไปป์ไลน์

กับดักสอง: --stream ปล่อยเฉพาะใบสเกลาร์; object และ array ว่างไม่มีเหตุการณ์ค่า {"a":{}} ให้แค่เหตุการณ์ปิดพาธ (พวก length == 1) และฟิลเตอร์ที่ดู length == 2 จะกลืนคอนเทนเนอร์ว่างเงียบ ๆ — ตัดสินใจชัดว่านับเข้าสถิติของคุณไหม

กับดักสาม: ผลลัพธ์บางส่วนหลัง parse error กลางไฟล์ ไปป์ไลน์สตรีมอาจปล่อยครึ่งหนึ่งของผลลัพธ์ไปแล้วก่อนสะดุด JSON พังท้าย ๆ jq 1.7 ล้มเสียงดังตามค่าเริ่มต้น — [1,] ได้ parse error: Expected another array element at line 1, column 4 โค้ด 5 ในการทดสอบของเรา — แต่ถ้าเชลล์ของคุณ redirect stdout ไปไฟล์ปลายทาง ผลลัพธ์ตัดขาดก็อยู่บนดิสก์ไปแล้ว เกราะวิศวกรรม: staging บวก rename — เขียนลงไฟล์ชั่วคราว แล้ว mv ทับปลายทางหลัง jq สำเร็จเท่านั้น อยากควบคุมละเอียดกว่านั้น --stream-errors เปลี่ยน parse error เป็นเหตุการณ์ที่ประมวลและหยุดชัดเจนผ่าน error ได้

เมื่อไหร่ไม่ควรใช้ jq: Miller และไปป์ไลน์ผสม

jq คือภาษาฟังก์ชันลแปลงต้นไม้ เก่งเรื่องปรับโครงสร้างลึก ๆ แต่พองานเสื่อมเป็น «กรองกับนับ gigabyte ของ log แบน» ก็มีเครื่องมือที่เหมาะกว่า เบนช์มาร์กของ dratini.tech บน JSONL 2,5 GB (กรอง + เลือกคอลัมน์):

เครื่องมือ เวลา RSS พีค
ไปป์ไลน์ jq ปกติ 48,2s 84 MB
jq -s OOM (ถูกฆ่ากระทั่ง RAM 16 GB+) —
Miller (mlr --json) 11,4s 18 MB
ripgrep + jq ผสม 8,1s 32 MB

กฎมีว่า: ซ้อนลึก ปรับโครงสร้าง ใช้รอบด้านใน CI — jq สถิติแบนหลายกิกะไบต์ เปอร์เซ็นไทล์ p95 JSONL เป็น TSV — คำสั่งเดียว mlr --json stats1 แทนสคริปต์ jq ด้วยหน่วยความจำคงที่ และถ้า ripgrep คัดบรรทัดไร้ค่า 90 % ออกก่อน jq ได้ แบบผสมเร็วที่สุด

FAQ

ไฟล์ใหญ่แค่ไหน jq -s ถึงอันตราย?

เกณฑ์ปฏิบัติ: พอไฟล์เกินครึ่งหนึ่งของหน่วยความจำที่มีให้สงสัยไว้ก่อน หน่วยความจำหลัง parse มัก 3–10 เท่าของข้อความ (9,5 เท่ากับ 220 MB ของเรา; รายงานภายนอกมีไฟล์ 4 GB ฆ่าเครื่อง 16 GB) เทียบ ls -lh กับ free -m ก่อน ใกล้ขอบก็เปลี่ยน -s เป็น reduce inputs

ทำไมต้องมี -n หน้า reduce inputs?

-n สั่งว่าอย่าเอาอินพุตแรกเป็นค่าเริ่มต้นของโปรแกรม เพื่อให้ inputs เป็นผู้ปล่อยรายการเอง ไม่มี -n รายการแรกกลายเป็นสถานะเริ่มต้นของ reduce และหายเงียบจากผลลัพธ์ — ข้อมูลหายโดยไม่มี error สักตัว

เลือกระหว่าง --stream กับโหมดปกติยังไง?

ดูรูปร่างไฟล์ก่อน JSONL เป็นสตรีมทีละบรรทัดอยู่แล้ว --stream ไร้ประโยชน์ สำหรับเอกสารใหญ่ชิ้นเดียวที่ต้องการแค่ค่าใบไม่กี่ค่า --stream แลกเวลา 3 เท่ากับหน่วยความจำน้อยกว่าร้อยเท่า ถ้าไฟล์ลงตัวหน่วยความจำ jq ปกติก็เร็วกว่าอยู่แล้ว

บรรทัดพังตอนสตรีมทำอย่างไร?

ใน JSONL fromjson? ข้ามบรรทัดที่ parse ไม่ได้ ให้บรรทัดเดียวไม่ฆ่าไปป์ไลน์ ส่วนเอกสารใหญ่ชิ้นเดียว parse error กลางไฟล์ทำให้รันล้มทั้งรอบ — เผยแพร่แบบอะตอมผ่านไฟล์ staging กับ rename หรือใช้ --stream-errors ควบคุมอย่างชัดเจน