JSON Toolkit

jq और बड़ी JSON फ़ाइलें: -s मेमरी क्यों फोड़ता है और स्ट्रीमिंग में कैसे लिखें

मुख्य बात: सैकड़ों MB JSON लॉग को jq -s से एकत्रित करना OOM में खत्म होता है, जबकि reduce inputs वही आंकड़े महज कुछ MB RAM में देता है। 220 MB और 20 लाख लाइनों के नमूने पर मापा गया: slurp 2.08 GB पर चरम पर पहुँचता है जबकि स्ट्रीमिंग रिड्यूसर मात्र 3.5 MB पर। यह लेख मेमरी खपत की प्रक्रिया, JSONL की लाइन-दर-लाइन प्रोसेसिंग, --stream के पाथ इवेंट और तीन वास्तविक जाल समझाता है, जिनमें -n --stream का खामोश खाली आउटपुट शामिल है।

उन्नत~6 मिनट पढ़ें2026-11-12 को प्रकाशित2026-11-12 को अपडेट किया गया
बड़े JSON पर jq streaming बनाम -s की मेमरी तुलना

jq तेज़ी से पार्स करता है, लेकिन कुछ सौ MB की फ़ाइल पर लगभग हर मृत्यु उसी फ्लैग पर लौटती है: -s पूरा इनपुट एक ही विशाल ऐरे में लोड कर देता है, और पीक RSS आसानी से फ़ाइल के आकार के कई गुना तक पहुँच जाता है।

एक फ़ाइल, दो क्वेरी: 580 गुना कम मेमरी

एक माप से शुरुआत करते हैं। नमूना 220 MB और 20,00,000 लाइनों का JSONL लॉग है (हर लाइन पर एक request रिकॉर्ड: timestamp, level, path, status, duration_ms, uid)। वातावरण: Linux x86_64 पर jq 1.7, पीक 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 समुदाय की 2.3 GB JSONL की अनुभव-रिपोर्ट बिलकुल वही कहानी सुनाती है — slurp पर OOM, फिर स्ट्रीमिंग रिड्यूसर 47 सेकंड में पूरा होता है RSS सिर्फ 30 MB से थोड़ा ऊपर। Dratini.tech ने 2.5 GB इनपुट पर jq -s को 16 GB+ मशीन पर भी OOM killer से मरते देखा, जबकि साधारण पाइपलाइन 48.2s में 84 MB पर निपट गई।

निष्कर्ष पहले: फ़ाइल उपलब्ध मेमरी के आधे से बड़ी हो तो -s उम्मीदवार भी नहीं है। कुछ भी लिखने से पहले तीन चीज़ें मापें: आकार के लिए ls -lh, मेमरी की गुंजाइश के लिए free -m, लाइन संख्या के लिए wc -l।

मेमरी असल में कहाँ जाती है

jq -s (slurp) दस्तावेज़ीकृत अर्थ है «सभी इनपुट ऐरे में पढ़ना»। वास्तविक लागत टेक्स्ट से कहीं आगे निकल जाती है: पार्सिंग के बाद jq C-संरचनाओं का एक ट्री थामे रहता है, और हर object, array, string और number अपना नोड मेटाडेटा सहित बहन करता है। हमारे 220 MB टेक्स्ट थोड़े 2 GB से ऊपर संरचनाओं में बदल गए — लगभग 9.5 गुना सूजन। group_by ऊपर से मेमरी में ही सॉर्ट और ग्रुप करता है, चरम को और बढ़ाता हुआ।

अकेला बड़ा JSON डॉक्यूमेंट भी वैसा ही व्यवहार करता है। वही लॉग 300 MB के रूट ऐरे में मोड़कर साधारण फ़िल्टर से निकालने पर:

क्वेरी समय पीक RSS
jq '.[] | select(.level=="ERROR") | .uid' (पूरा डॉक्यूमेंट) 4.7s 1.85 GB
jq --stream 'select(...)' (पाथ इवेंट) 13.4s 3.4 MB

पूरा पार्सिंग अब भी 1.8 GB के आसपास चरम पर पहुँचता है — फ़िल्टर चलने से पहले ही jq पूरा ट्री बना देता है। --stream करीब 3 गुना रनटाइम एवज़ में 540 गुना छोटी मेमरी लेता है। इस सूजन का विस्तृत मॉडल मेमरी कहाँ से आती है में विकसित किया गया है।

JSONL लॉग: लाइन-दर-लाइन पढ़ना पहले से ही स्ट्रीम है

अगर आपकी «बड़ी फ़ाइल» असल में JSONL है — हर लाइन पर एक object — तो jq का डिफ़ॉल्ट व्यवहार पहले से ही स्ट्रीम है: हर लाइन स्वतंत्र रूप से पार्स और एमिट होती है, और -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 फ़िल्टर करता है; ट्रांसफ़ॉर्मेशन के बाद फ़िल्टर करना कम्प्यूटेशन की बर्बादी है।
  • कच्ची स्ट्रिंगों के लिए -r। बिना इसके आउटपुट कोट की गई JSON स्ट्रिंग होती है, और uniq -c "ERROR" और ERROR को दो अलग मान गिन देगा।

खराब लाइनों के लिए fromjson? इस्तेमाल करें: jq -r 'fromjson? | .level' जो लाइनें पार्स नहीं होतीं उन्हें ख़ामोशी से छोड़ देता है, और कटा हुआ टुकड़ा पूरी पाइपलाइन नहीं मारता। फ़ॉर्मैट खुद 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 के पाथ इवेंट

जब इनपुट एक ही बिशाल रूट डॉक्यूमेंट हो (कुछ सौ 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"

इवेंट स्ट्रीम से निकालने के लिए पाथ का पूरा रूप मिलाना ज़रूरी है — गहराई, सदस्यों के नाम, इंडेक्स की स्थितियाँ — क्योंकि सिर्फ आख़िरी घटक जाँचने पर नेस्टेड ऑब्जेक्टों के होमोनिम कीज़ भी पकड़ में आ जाएँगी:

# सिर्फ 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 से ग्रहण करने होंगे — जाल देखें)। पुनर्निर्माण के लिए — इवेंट स्ट्रीम को वापस पूरे ऑब्जेक्टों में बदलने के लिए — truncate_stream और fromstream जोड़ें। आकार के अनुसार उपकरण चयन का सार JSON फ़ाइल बहुत बड़ी? में है।

तीन वास्तविक जाल

जाल एक: inputs के बिना -n --stream ख़ामोशी से कुछ भी आउटपुट नहीं देता। इसी मशीन पर सिद्ध: jq -n --stream 'select(...)' file.json कोड 0 से खत्म, बिना आउटपुट या त्रुटि — -n मोड में jq इनपुट नहीं पढ़ता, और फ़िल्टर का select एक भी इवेंट नहीं पाता। सही: -n हटाकर खाला --stream इस्तेमाल करें, या -n --stream को reduce inputs के साथ जोड़ें। «सफल पर खाली» इस श्रेणी की विफलताएँ डिबग करने में सबसे कठिन हैं; पाइपलाइन गूँथने से पहले छोटे नमूने पर प्रमाणित करें।

जाल दो: --stream सिर्फ स्केलर लीफ एमिट करता है; खाली ऑब्जेक्ट और ऐरे का कोई वैल्यू इवेंट नहीं। {"a":{}} केवल पाथ-बंद इवेंट देता है (length == 1 वाला), और length == 2 पर फ़िल्टर खाली कंटेनर ख़ामोशी से निगल लेगा — साफ़ तय करें कि वे आपके आंकड़ों में गिने जाएँगे या नहीं।

जाल तीन: फ़ाइल के बीच पार्स एरर के बाद आंशिक परिणाम। स्ट्रीमिंग पाइपलाइन आधा आउटपुट एमिट कर चुकी हो सकती है जब आख़िर में टूटा JSON टकराए। jq 1.7 डिफ़ॉल्ट रूप से ऊँची आवाज़ में गिरता है — हमारे टेस्ट में [1,] ने दिया parse error: Expected another array element at line 1, column 4, कोड 5 — लेकिन अगर आपका शेल stdout को लक्ष्य फ़ाइल में रीडायरेक्ट करता है, तो कटा परिणाम डिस्क पर पहले से बैठा है। इंजीनियरिंग ढाल: staging और rename — अस्थायी फ़ाइल में लिखें और jq सफल होने के बाद ही mv से लक्ष्य पर रखें। और परिष्कृत नियंत्रण के लिए --stream-errors पार्स एररों को इवेंट में बदल देता है जिन्हें आप प्रोसेस कर सकते हैं और error से साफ़-साफ़ रोक सकते हैं।

jq कब न काम में लें: Miller और हाइब्रिड पाइपलाइन

jq ट्री ट्रांसफ़ॉर्मेशन की फंक्शनल भाषा है, गहरी पुनर्रचना में दमदार। पर जैसे ही काम «फ्लैट लॉग के गीगाबाइट फ़िल्टर और गिनती» में घटित हो जाए, बेहतर सिले-कटे उपकरण मौजूद हैं। dratini.tech का बेंचमार्क, 2.5 GB JSONL पर (फ़िल्टर + कॉलम चयन):

उपकरण समय पीक RSS
साधारण jq पाइपलाइन 48.2s 84 MB
jq -s OOM (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 jq से पहले 90% फ़ालतू लाइनें छाँट सकता है तो हाइब्रिड रास्ता सबसे तेज़।

FAQ

कितनी बड़ी फ़ाइल से jq -s ख़तरनाक हो जाता है?

व्यावहारिक सीमा: फ़ाइल उपलब्ध मेमरी के आधे को पार करते ही शक करें। पार्सिंग के बाद मेमरी आम तौर पर टेक्स्ट का 3–10 गुना होती है (हमारे 220 MB पर 9.5 गुना; तीसरे पक्ष की रिपोर्ट में 4 GB फ़ाइल 16 GB मशीन मारती है)। पहले ls -lh को free -m से तुलना करें, और सीमा के पास -s की जगह reduce inputs लें।

reduce inputs से पहले -n क्यों?

-n jq को बताता है पहला इनपुट प्रोग्राम का आरंभिक मान न बने, ताकि inputs खुद हर रिकॉर्ड एमिट करे। -n के बिना पहला रिकॉर्ड reduce की आरंभिक अवस्था बन जाता है और नतीजे से ख़ामोशी से ग़ायब हो जाता है — बिना किसी त्रुटि के डेटा हानि।

--stream और साधारण मोड के बीच कैसे चुनें?

पहले फ़ाइल का रूप देखें। JSONL पहले से लाइन-दर-लाइन स्ट्रीम है; --stream कुछ देता नहीं। अकेले बड़े डॉक्यूमेंट से जब सिर्फ कुछ लीफ वैल्यू चाहिए हों, --stream करीब 3 गुना समय एवज़ में सैकड़ों गुना कम मेमरी लेता है। फ़ाइल मेमरी में समा जाए तो साधारण jq ही बरं तेज़ है।

स्ट्रीमिंग में टूटी लाइनें आएँ तो क्या करें?

JSONL में fromjson? पार्स-अयोग्य लाइनें छोड़ देता है, ताकि एक गंदी लाइन पाइपलाइन न मारे। अकेले बड़े डॉक्यूमेंट में बीच का पार्स एरर पूरी रन गिरा देता है — staging फ़ाइल और rename से एटॉमिक प्रकाशन करें, या साफ़ नियंत्रण के लिए --stream-errors लें।