मैंने बहुत सारे प्रयोग किए हैं और यहाँ मेरे निष्कर्ष हैं।
जिन और छँटाई
वर्तमान में GIN इंडेक्स (संस्करण 9.4 के अनुसार) ऑर्डर करने में सहायता नहीं कर सकता है ।
वर्तमान में PostgreSQL द्वारा समर्थित इंडेक्स प्रकारों में से, केवल बी-ट्री सॉर्ट किए गए आउटपुट का उत्पादन कर सकते हैं - अन्य सूचकांक प्रकार एक अनिर्दिष्ट, कार्यान्वयन-निर्भर क्रम में पंक्तियों से मेल खाते हैं।
work_mem
इस कॉन्फ़िगरेशन पैरामीटर को इंगित करने के लिए धन्यवाद क्रिस । यह 4MB तक डिफॉल्ट करता है, और अगर आपका रिकॉर्डसेट बड़ा है, तो work_mem
उचित मूल्य तक बढ़ सकता है (इससे पाया जा सकता है EXPLAIN ANALYSE
) सॉर्ट ऑपरेशन को गति प्रदान कर सकता है।
ALTER SYSTEM SET work_mem TO '32MB';
परिवर्तन को प्रभावी करने के लिए सर्वर को पुनरारंभ करें, फिर डबल चेक करें:
SHOW work_mem;
मूल प्रश्न
मैंने अपने डेटाबेस को ६५०k उत्पादों के साथ आबाद किया है जिसमें कुछ श्रेणियां ४०k उत्पादों तक हैं। मैंने published
क्लॉज को हटाकर क्वेरी को थोड़ा सरल बनाया है :
SELECT * FROM products WHERE category_ids @> ARRAY [248688]
ORDER BY score DESC, title LIMIT 10 OFFSET 30000;
Limit (cost=2435.62..2435.62 rows=1 width=1390) (actual time=1141.254..1141.256 rows=10 loops=1)
-> Sort (cost=2434.00..2435.62 rows=646 width=1390) (actual time=1115.706..1140.513 rows=30010 loops=1)
Sort Key: score, title
Sort Method: external merge Disk: 29656kB
-> Bitmap Heap Scan on products (cost=17.01..2403.85 rows=646 width=1390) (actual time=11.831..25.646 rows=41666 loops=1)
Recheck Cond: (category_ids @> '{248688}'::integer[])
Heap Blocks: exact=6471
-> Bitmap Index Scan on idx_products_category_ids_gin (cost=0.00..16.85 rows=646 width=0) (actual time=10.140..10.140 rows=41666 loops=1)
Index Cond: (category_ids @> '{248688}'::integer[])
Planning time: 0.288 ms
Execution time: 1146.322 ms
जैसा कि हम देख सकते हैं work_mem
पर्याप्त नहीं था इसलिए हमारे पास Sort Method: external merge Disk: 29656kB
(यहां संख्या अनुमानित है, इसे इन-मेमोरी एस्कॉर्ट के लिए 32 एमबी से थोड़ा अधिक की आवश्यकता है)।
स्मृति पदचिह्न कम करें
सॉर्ट करने के लिए पूर्ण रिकॉर्ड का चयन न करें, आईडी का उपयोग करें, सॉर्ट, ऑफ़सेट और सीमा लागू करें, फिर केवल 10 रिकॉर्ड लोड करें जो हमें चाहिए:
SELECT * FROM products WHERE id in (
SELECT id FROM products WHERE category_ids @> ARRAY[248688]
ORDER BY score DESC, title LIMIT 10 OFFSET 30000
) ORDER BY score DESC, title;
Sort (cost=2444.10..2444.11 rows=1 width=1390) (actual time=707.861..707.862 rows=10 loops=1)
Sort Key: products.score, products.title
Sort Method: quicksort Memory: 35kB
-> Nested Loop (cost=2436.05..2444.09 rows=1 width=1390) (actual time=707.764..707.803 rows=10 loops=1)
-> HashAggregate (cost=2435.63..2435.64 rows=1 width=4) (actual time=707.744..707.746 rows=10 loops=1)
Group Key: products_1.id
-> Limit (cost=2435.62..2435.62 rows=1 width=72) (actual time=707.732..707.734 rows=10 loops=1)
-> Sort (cost=2434.00..2435.62 rows=646 width=72) (actual time=704.163..706.955 rows=30010 loops=1)
Sort Key: products_1.score, products_1.title
Sort Method: quicksort Memory: 7396kB
-> Bitmap Heap Scan on products products_1 (cost=17.01..2403.85 rows=646 width=72) (actual time=11.587..35.076 rows=41666 loops=1)
Recheck Cond: (category_ids @> '{248688}'::integer[])
Heap Blocks: exact=6471
-> Bitmap Index Scan on idx_products_category_ids_gin (cost=0.00..16.85 rows=646 width=0) (actual time=9.883..9.883 rows=41666 loops=1)
Index Cond: (category_ids @> '{248688}'::integer[])
-> Index Scan using products_pkey on products (cost=0.42..8.45 rows=1 width=1390) (actual time=0.004..0.004 rows=1 loops=10)
Index Cond: (id = products_1.id)
Planning time: 0.682 ms
Execution time: 707.973 ms
ध्यान दें Sort Method: quicksort Memory: 7396kB
। रिजल्ट ज्यादा बेहतर है।
जोइन और अतिरिक्त बी-ट्री इंडेक्स
जैसा कि क्रिस ने सलाह दी है कि मैंने अतिरिक्त सूचकांक बनाया है:
CREATE INDEX idx_test7 ON products (score DESC, title);
पहले मैंने इस तरह जुड़ने की कोशिश की:
SELECT * FROM products NATURAL JOIN
(SELECT id FROM products WHERE category_ids @> ARRAY[248688]
ORDER BY score DESC, title LIMIT 10 OFFSET 30000) c
ORDER BY score DESC, title;
क्वेरी योजना थोड़ी अलग है, लेकिन परिणाम समान है:
Sort (cost=2444.10..2444.11 rows=1 width=1390) (actual time=700.747..700.747 rows=10 loops=1)
Sort Key: products.score, products.title
Sort Method: quicksort Memory: 35kB
-> Nested Loop (cost=2436.05..2444.09 rows=1 width=1390) (actual time=700.651..700.690 rows=10 loops=1)
-> HashAggregate (cost=2435.63..2435.64 rows=1 width=4) (actual time=700.630..700.630 rows=10 loops=1)
Group Key: products_1.id
-> Limit (cost=2435.62..2435.62 rows=1 width=72) (actual time=700.619..700.619 rows=10 loops=1)
-> Sort (cost=2434.00..2435.62 rows=646 width=72) (actual time=697.304..699.868 rows=30010 loops=1)
Sort Key: products_1.score, products_1.title
Sort Method: quicksort Memory: 7396kB
-> Bitmap Heap Scan on products products_1 (cost=17.01..2403.85 rows=646 width=72) (actual time=10.796..32.258 rows=41666 loops=1)
Recheck Cond: (category_ids @> '{248688}'::integer[])
Heap Blocks: exact=6471
-> Bitmap Index Scan on idx_products_category_ids_gin (cost=0.00..16.85 rows=646 width=0) (actual time=9.234..9.234 rows=41666 loops=1)
Index Cond: (category_ids @> '{248688}'::integer[])
-> Index Scan using products_pkey on products (cost=0.42..8.45 rows=1 width=1390) (actual time=0.004..0.004 rows=1 loops=10)
Index Cond: (id = products_1.id)
Planning time: 1.015 ms
Execution time: 700.918 ms
विभिन्न ऑफसेट और उत्पाद की गिनती के साथ खेलना मैं PostgreSQL अतिरिक्त बी-ट्री इंडेक्स का उपयोग नहीं कर सका।
इसलिए मैंने शास्त्रीय तरीका अपनाया और जंक्शन टेबल बनाई :
CREATE TABLE prodcats AS SELECT id AS product_id, unnest(category_ids) AS category_id FROM products;
CREATE INDEX idx_prodcats_cat_prod_id ON prodcats (category_id, product_id);
SELECT p.* FROM products p JOIN prodcats c ON (p.id=c.product_id)
WHERE c.category_id=248688
ORDER BY p.score DESC, p.title LIMIT 10 OFFSET 30000;
Limit (cost=122480.06..122480.09 rows=10 width=1390) (actual time=1290.360..1290.362 rows=10 loops=1)
-> Sort (cost=122405.06..122509.00 rows=41574 width=1390) (actual time=1264.250..1289.575 rows=30010 loops=1)
Sort Key: p.score, p.title
Sort Method: external merge Disk: 29656kB
-> Merge Join (cost=50.46..94061.13 rows=41574 width=1390) (actual time=117.746..182.048 rows=41666 loops=1)
Merge Cond: (p.id = c.product_id)
-> Index Scan using products_pkey on products p (cost=0.42..90738.43 rows=646067 width=1390) (actual time=0.034..116.313 rows=210283 loops=1)
-> Index Only Scan using idx_prodcats_cat_prod_id on prodcats c (cost=0.43..1187.98 rows=41574 width=4) (actual time=0.022..7.137 rows=41666 loops=1)
Index Cond: (category_id = 248688)
Heap Fetches: 0
Planning time: 0.873 ms
Execution time: 1294.826 ms
फिर भी बी-ट्री इंडेक्स का उपयोग नहीं करना, परिणामी फिट नहीं हुआ work_mem
, इसलिए खराब परिणाम।
लेकिन कुछ परिस्थितियों में, बड़ी संख्या में उत्पाद और छोटे ऑफ़ग्रेग्रेसक्यूएल अब बी-ट्री इंडेक्स का उपयोग करने का निर्णय लेते हैं:
SELECT p.* FROM products p JOIN prodcats c ON (p.id=c.product_id)
WHERE c.category_id=248688
ORDER BY p.score DESC, p.title LIMIT 10 OFFSET 300;
Limit (cost=3986.65..4119.51 rows=10 width=1390) (actual time=264.176..264.574 rows=10 loops=1)
-> Nested Loop (cost=0.98..552334.77 rows=41574 width=1390) (actual time=250.378..264.558 rows=310 loops=1)
-> Index Scan using idx_test7 on products p (cost=0.55..194665.62 rows=646067 width=1390) (actual time=0.030..83.026 rows=108037 loops=1)
-> Index Only Scan using idx_prodcats_cat_prod_id on prodcats c (cost=0.43..0.54 rows=1 width=4) (actual time=0.001..0.001 rows=0 loops=108037)
Index Cond: ((category_id = 248688) AND (product_id = p.id))
Heap Fetches: 0
Planning time: 0.585 ms
Execution time: 264.664 ms
यह वास्तव में काफी तार्किक है क्योंकि बी-ट्री इंडेक्स प्रत्यक्ष परिणाम नहीं देता है, यह केवल अनुक्रमिक स्कैन के लिए एक गाइड के रूप में उपयोग किया जाता है।
GIN क्वेरी से तुलना करें:
SELECT * FROM products WHERE id in (
SELECT id FROM products WHERE category_ids @> ARRAY[248688]
ORDER BY score DESC, title LIMIT 10 OFFSET 300
) ORDER BY score DESC, title;
Sort (cost=2519.53..2519.55 rows=10 width=1390) (actual time=143.809..143.809 rows=10 loops=1)
Sort Key: products.score, products.title
Sort Method: quicksort Memory: 35kB
-> Nested Loop (cost=2435.14..2519.36 rows=10 width=1390) (actual time=143.693..143.736 rows=10 loops=1)
-> HashAggregate (cost=2434.71..2434.81 rows=10 width=4) (actual time=143.678..143.680 rows=10 loops=1)
Group Key: products_1.id
-> Limit (cost=2434.56..2434.59 rows=10 width=72) (actual time=143.668..143.670 rows=10 loops=1)
-> Sort (cost=2433.81..2435.43 rows=646 width=72) (actual time=143.642..143.653 rows=310 loops=1)
Sort Key: products_1.score, products_1.title
Sort Method: top-N heapsort Memory: 68kB
-> Bitmap Heap Scan on products products_1 (cost=17.01..2403.85 rows=646 width=72) (actual time=11.625..31.868 rows=41666 loops=1)
Recheck Cond: (category_ids @> '{248688}'::integer[])
Heap Blocks: exact=6471
-> Bitmap Index Scan on idx_products_category_ids_gin (cost=0.00..16.85 rows=646 width=0) (actual time=9.916..9.916 rows=41666 loops=1)
Index Cond: (category_ids @> '{248688}'::integer[])
-> Index Scan using products_pkey on products (cost=0.42..8.45 rows=1 width=1390) (actual time=0.004..0.004 rows=1 loops=10)
Index Cond: (id = products_1.id)
Planning time: 0.630 ms
Execution time: 143.921 ms
GIN का परिणाम काफी बेहतर है। मैंने उत्पादों की संख्या और ऑफसेट के विभिन्न संयोजनों के साथ जाँच की, किसी भी परिस्थिति में जंक्शन टेबल दृष्टिकोण किसी भी बेहतर नहीं था ।
वास्तविक सूचकांक की शक्ति
PostgreSQL को छँटाई के लिए पूरी तरह से सूचकांक का उपयोग करने के लिए, सभी क्वेरी WHERE
मापदंडों के साथ-साथ ORDER BY
मापदंडों को एकल बी-ट्री इंडेक्स में रहना चाहिए। ऐसा करने के लिए मैंने उत्पाद से जंक्शन टेबल तक सॉर्ट फ़ील्ड की प्रतिलिपि बनाई है:
CREATE TABLE prodcats AS SELECT id AS product_id, unnest(category_ids) AS category_id, score, title FROM products;
CREATE INDEX idx_prodcats_1 ON prodcats (category_id, score DESC, title, product_id);
SELECT * FROM products WHERE id in (SELECT product_id FROM prodcats WHERE category_id=248688 ORDER BY score DESC, title LIMIT 10 OFFSET 30000) ORDER BY score DESC, title;
Sort (cost=2149.65..2149.67 rows=10 width=1390) (actual time=7.011..7.011 rows=10 loops=1)
Sort Key: products.score, products.title
Sort Method: quicksort Memory: 35kB
-> Nested Loop (cost=2065.26..2149.48 rows=10 width=1390) (actual time=6.916..6.950 rows=10 loops=1)
-> HashAggregate (cost=2064.83..2064.93 rows=10 width=4) (actual time=6.902..6.904 rows=10 loops=1)
Group Key: prodcats.product_id
-> Limit (cost=2064.02..2064.71 rows=10 width=74) (actual time=6.893..6.895 rows=10 loops=1)
-> Index Only Scan using idx_prodcats_1 on prodcats (cost=0.56..2860.10 rows=41574 width=74) (actual time=0.010..6.173 rows=30010 loops=1)
Index Cond: (category_id = 248688)
Heap Fetches: 0
-> Index Scan using products_pkey on products (cost=0.42..8.45 rows=1 width=1390) (actual time=0.003..0.003 rows=1 loops=10)
Index Cond: (id = prodcats.product_id)
Planning time: 0.318 ms
Execution time: 7.066 ms
और यह चयनित श्रेणी और बड़ी ऑफसेट में बड़ी संख्या में उत्पादों के साथ सबसे खराब परिदृश्य है। जब ऑफसेट = 300 निष्पादन समय सिर्फ 0.5 एमएस है।
दुर्भाग्य से इस तरह के जंक्शन टेबल को बनाए रखने के लिए अतिरिक्त प्रयास की आवश्यकता होती है। यह अनुक्रमित भौतिक विचारों के माध्यम से पूरा किया जा सकता है, लेकिन यह केवल तब उपयोगी होता है जब आपके डेटा को शायद ही कभी अपडेट किया जाता है, क्योंकि ऐसे भौतिक दृश्य को ताज़ा करना काफी भारी ऑपरेशन होता है।
इसलिए मैं अभी तक GIN सूचकांक के साथ रह रहा हूं, work_mem
स्मृति पदचिह्न क्वेरी को बढ़ाया और घटाया है।