PostgreSQL प्रदर्शन और क्वेरी अनुकूलन · पाठ

TOAST की आंतरिक कार्यप्रणाली और बड़े मानों का संग्रहण

समझें कि PostgreSQL अत्यधिक बड़े columns को कैसे संग्रहीत करता है और compression तथा external storage की सीमाओं को कैसे समायोजित करें।

पाठ 4, कुल 4 में से13 चरण

TOAST की आंतरिक कार्यप्रणाली और बड़े मानों का संग्रहण, CoddyKit पर PostgreSQL प्रदर्शन और क्वेरी अनुकूलन का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह PostgreSQL प्रदर्शन और क्वेरी अनुकूलन सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। PostgreSQL प्रदर्शन और क्वेरी अनुकूलन पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

TOAST क्यों मौजूद है

PostgreSQL पंक्तियों को निश्चित आकार वाले 8 KB पृष्ठों पर संग्रहीत करता है। एक पंक्ति कई पृष्ठों में विभाजित नहीं हो सकती, इसलिए कोई बड़ा मान (लंबा text, बड़ा jsonb या bytea) कभी फिट नहीं होगा।

TOAST (The Oversized-Attribute Storage Technique) बड़े कॉलमों को संपीड़ित करके इस समस्या का समाधान करता है और, यदि वे फिर भी बहुत बड़े हों, तो उन्हें अलग-अलग खंडों में बाँटकर एक अलग सहायक तालिका में संग्रहीत करता है।

मुख्य हीप पंक्ति छोटी और कैश के अनुकूल रहती है।
किसी तार्किक मान का आकार 8 KB से बहुत अधिक (लगभग 1 GB तक) हो सकता है।
यह आपकी क्वेरी के लिए स्वचालित और पारदर्शी रूप से होता है।

TOAST सीमा

TOAST तब सक्रिय होता है जब किसी पंक्ति का कुल आकार TOAST_TUPLE_THRESHOLD से अधिक हो जाए, जो डिफ़ॉल्ट रूप से 2 KB (8 KB पृष्ठ का एक-चौथाई) है।

यह सीमा पार होने पर PostgreSQL सबसे बड़े TOAST-योग्य गुणों को तब तक संपीड़ित करता है और/या पंक्ति से बाहर स्थानांतरित करता है, जब तक पंक्ति TOAST_TUPLE_TARGET (यह भी लगभग 2 KB) से छोटी न हो जाए।

केवल परिवर्तनीय-लंबाई वाले प्रकारों के कॉलम (text, varchar, jsonb, bytea, ऐरे आदि) को TOAST किया जा सकता है। integer या timestamptz जैसे निश्चित-चौड़ाई वाले प्रकारों को कभी TOAST नहीं किया जाता।

TOAST तालिका ढूँढना

कम-से-कम एक TOAST-योग्य कॉलम वाली प्रत्येक तालिका को pg_toast.pg_toast_<oid> नाम की संबद्ध TOAST तालिका मिलती है। आप इसे कैटलॉग से ढूँढ सकते हैं।

reltoastrelid कॉलम किसी हीप संबंध को उसके TOAST संबंध से जोड़ता है; 0 का मान होने का अर्थ है कि कोई TOAST तालिका बनाई नहीं गई।

SELECT c.relname,
       c.reltoastrelid,
       t.relname AS toast_table
FROM pg_class c
LEFT JOIN pg_class t ON t.oid = c.reltoastrelid
WHERE c.relname = 'documents';

चार भंडारण रणनीतियाँ

प्रत्येक कॉलम की एक भंडारण रणनीति होती है, जो यह नियंत्रित करती है कि उसे संपीड़ित किया जा सकता है और/या पंक्ति से बाहर स्थानांतरित किया जा सकता है:

PLAIN — न संपीड़न, न पंक्ति से बाहर भंडारण; केवल गैर-TOAST-योग्य प्रकारों के लिए मान्य।
EXTENDED — संपीड़न और पंक्ति से बाहर भंडारण, दोनों की अनुमति (अधिकांश varlena प्रकारों के लिए डिफ़ॉल्ट)।
EXTERNAL — पंक्ति से बाहर भंडारण की अनुमति, लेकिन संपीड़न नहीं (उपस्ट्रिंग तक तेज़ पहुँच)।
MAIN — संपीड़न की अनुमति, लेकिन अत्यंत आवश्यक होने तक मुख्य तालिका में ही रखें।

प्रति-कॉलम भंडारण की जाँच

प्रत्येक कॉलम की रणनीति देखने के लिए pg_attribute.attstorage से क्वेरी करें। कोड इस प्रकार हैं: p=PLAIN, e=EXTERNAL, m=MAIN, x=EXTENDED।

SELECT attname,
       atttypid::regtype AS type,
       CASE attstorage
         WHEN 'p' THEN 'plain'
         WHEN 'e' THEN 'external'
         WHEN 'm' THEN 'main'
         WHEN 'x' THEN 'extended'
       END AS storage
FROM pg_attribute
WHERE attrelid = 'documents'::regclass
  AND attnum > 0
  AND NOT attisdropped;

कॉलम की रणनीति बदलना

डिफ़ॉल्ट को बदलने के लिए ALTER TABLE ... SET STORAGE का उपयोग करें। एक सामान्य अनुकूलन यह है: यदि आप बड़े bytea के यादृच्छिक उपस्ट्रिंग बार-बार पढ़ते हैं (जैसे किसी बाइनरी बड़े ऑब्जेक्ट से श्रेणी-पठन), तो EXTERNAL पर बदल दें, ताकि मान बिना संपीड़ित किए संग्रहीत हों और पूरे मान को विसंपीड़ित किए बिना उनका कुछ भाग पढ़ा जा सके।

नई रणनीति केवल बदलाव के बाद लिखी गई पंक्तियों पर लागू होती है; मौजूदा डेटा को अपडेट किए जाने तक फिर से नहीं लिखा जाता।

ALTER TABLE documents
  ALTER COLUMN payload SET STORAGE EXTERNAL;

-- Force a rewrite to apply it to existing rows:
VACUUM FULL documents;

संपीड़न एल्गोरिदम: pglz बनाम lz4

PostgreSQL पंक्ति से बाहर भंडारण पर विचार करने से पहले TOAST मानों को संपीड़ित करता है। दो एल्गोरिदम उपलब्ध हैं:

pglz — पुराना अंतर्निहित एल्गोरिदम, ठीक अनुपात लेकिन धीमा।
lz4 — PostgreSQL 14 से उपलब्ध, संपीड़न और विसंपीड़न में बहुत तेज़, लेकिन अनुपात थोड़ा कम। इसके लिए सर्वर को lz4 समर्थन के साथ बनाया जाना आवश्यक है।

पूरे क्लस्टर का डिफ़ॉल्ट default_toast_compression से सेट किया जाता है।

SHOW default_toast_compression;

-- Set lz4 cluster-wide (postgresql.conf or per session):
SET default_toast_compression = 'lz4';

प्रति-कॉलम संपीड़न

PostgreSQL 14 और उसके बाद के संस्करणों में आप अलग-अलग कॉलमों पर SET COMPRESSION से संपीड़न विधि सेट कर सकते हैं। यह भंडारण रणनीति से स्वतंत्र होती है।

ऐसे बड़े और बार-बार उपयोग होने वाले कॉलमों के लिए lz4 चुनें जहाँ पढ़ने/लिखने के दौरान CPU का समय महत्वपूर्ण हो; जब संपीड़न अनुपात या उपस्ट्रिंग तक पहुँच अधिक महत्वपूर्ण हो, तब pglz रखें या EXTERNAL का उपयोग करें।

ALTER TABLE documents
  ALTER COLUMN body SET COMPRESSION lz4;

-- Inspect chosen method per column:
SELECT attname, attcompression
FROM pg_attribute
WHERE attrelid = 'documents'::regclass
  AND attnum > 0;

पंक्ति से बाहर लक्ष्य को ट्यून करना

toast_tuple_target रिलऑप्शन यह नियंत्रित करता है कि PostgreSQL गुणों को पंक्ति से बाहर कितनी आक्रामकता से भेजता है: यह वह आकार निर्धारित करता है जिसकी ओर मुख्य ट्यूपल को छोटा किया जाता है (मान्य सीमा 128 बाइट से लगभग 8160 बाइट तक)।

इसे कम करने पर अधिक मान जल्दी TOAST में चले जाते हैं, जिससे मुख्य हीप घना रहता है और बड़े कॉलम कम पढ़े जाने पर स्कैन का प्रदर्शन बेहतर होता है। इसे बढ़ाने पर अधिक डेटा पंक्ति के भीतर रहता है।

ALTER TABLE documents
  SET (toast_tuple_target = 512);

-- Verify current reloptions:
SELECT reloptions
FROM pg_class
WHERE relname = 'documents';

TOAST का आकार मापना

मुख्य तालिका के बाइट और TOAST के बाइट अलग-अलग देखने के लिए आकार फ़ंक्शन का उपयोग करें। इससे पता चलता है कि अनावश्यक डेटा हीप में है या बड़े मानों में।

pg_table_size — हीप + TOAST + उनकी TOAST अनुक्रमिकाएँ, सामान्य अनुक्रमिकाओं को छोड़कर।
pg_relation_size(rel, 'main') — केवल मुख्य फ़ोर्क।

SELECT
  pg_size_pretty(pg_relation_size('documents'))        AS heap,
  pg_size_pretty(
    pg_total_relation_size(reltoastrelid)
  )                                                     AS toast,
  pg_size_pretty(pg_total_relation_size('documents'))  AS total
FROM pg_class
WHERE relname = 'documents';

व्यावहारिक प्रदर्शन संबंधी प्रभाव

TOAST तब तक अदृश्य रहता है, जब तक उसके प्रभाव दिखाई न देने लगें। याद रखने योग्य मुख्य बातें:

TOAST किए गए कॉलम को पढ़ने पर TOAST तालिका में अतिरिक्त अनुक्रमणिका खोज और संभावित विसंपीड़न होता है — जब आपको केवल छोटे कॉलम चाहिए हों, तब SELECT * से बचें।
जिन UPDATE में उन कॉलमों को नहीं छुआ जाता, उनमें मान TOAST किए हुए ही रहते हैं, इसलिए असंबंधित अपडेट सस्ते होते हैं।
EXTERNAL बड़े, बिना संपीड़ित बाइनरी ऑब्जेक्ट पर कुशल substr() या श्रेणी-पठन सक्षम करता है।
अधिक प्रविष्टियों और बड़े मानों वाले कार्यभार में pglz से lz4 पर बदलने से लिखने के लिए लगने वाला CPU समय बहुत घट सकता है।

त्वरित जाँच

आपके पास एक तालिका है, जिसके बड़े bytea कॉलम को अधिकतर छोटे बाइट-क्षेत्रों पर substr() के माध्यम से पढ़ा जाता है। ये पठन धीमे हैं क्योंकि हर पहुँच पर पूरा मान विसंपीड़ित होता है। इसे ठीक करने वाला सबसे अच्छा एकल बदलाव कौन-सा है?

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन

आपने सीखा कि PostgreSQL बड़े आकार वाले मानों को कैसे संभालता है:

जब किसी पंक्ति का आकार लगभग 2 KB की सीमा से अधिक होने वाला होता है, तब TOAST सक्रिय होता है। यह पहले बड़े varlena कॉलमों को संपीड़ित करता है और फिर उन्हें pg_toast.* तालिकाओं में स्थानांतरित करता है।
चार रणनीतियाँ — PLAIN, MAIN, EXTENDED (डिफ़ॉल्ट), EXTERNAL — संपीड़न और पंक्ति से बाहर रखने को नियंत्रित करती हैं; इन्हें ALTER TABLE ... SET STORAGE से सेट किया जाता है।
lz4 (PG14+) pglz की तुलना में तेज़ संपीड़न देता है; इसे प्रति-कॉलम SET COMPRESSION से या पूरे क्लस्टर के लिए default_toast_compression से चुनें।
toast_tuple_target यह ट्यून करता है कि मान हीप से कितनी जल्दी बाहर जाएँ; आकार फ़ंक्शन बताते हैं कि कितना भंडारण TOAST में है।
उपस्ट्रिंग या श्रेणी-पठन के लिए EXTERNAL, अधिक लेखन वाले बड़े मानों के लिए lz4 चुनें और अनावश्यक विसंपीड़न से बचने के लिए SELECT * से बचें।

शुरुआत निःशुल्क

एआई शिक्षक के साथ SQL सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 22
पाठ: 88

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “TOAST की आंतरिक कार्यप्रणाली और बड़े मानों का संग्रहण” पाठ निःशुल्क है?

हाँ — PostgreSQL प्रदर्शन और क्वेरी अनुकूलन अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “TOAST की आंतरिक कार्यप्रणाली और बड़े मानों का संग्रहण” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। PostgreSQL प्रदर्शन और क्वेरी अनुकूलन पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“TOAST की आंतरिक कार्यप्रणाली और बड़े मानों का संग्रहण” में मैं क्या सीखूँगा?

समझें कि PostgreSQL अत्यधिक बड़े columns को कैसे संग्रहीत करता है और compression तथा external storage की सीमाओं को कैसे समायोजित करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ PostgreSQL प्रदर्शन और क्वेरी अनुकूलन का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या PostgreSQL प्रदर्शन और क्वेरी अनुकूलन शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर PostgreSQL प्रदर्शन और क्वेरी अनुकूलन शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“TOAST की आंतरिक कार्यप्रणाली और बड़े मानों का संग्रहण” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस PostgreSQL प्रदर्शन और क्वेरी अनुकूलन पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर PostgreSQL प्रदर्शन और क्वेरी अनुकूलन पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

Table और Index Bloat को सटीकता से मापना
pg_repack से स्थान पुनः प्राप्त करना
Update-प्रधान Tables के लिए Fillfactor का समायोजन
TOAST की आंतरिक कार्यप्रणाली और बड़े मानों का संग्रहण

← PostgreSQL प्रदर्शन और क्वेरी अनुकूलन पर वापस जाएँ