20M पंक्तियों पर Postgres में एक 'नवीनतम' क्वेरी का अनुकूलन

Question

मेरी तालिका इस प्रकार है:

    Column             |    Type           |    
-----------------------+-------------------+
 id                    | integer           | 
 source_id             | integer           | 
 timestamp             | integer           | 
 observation_timestamp | integer           | 
 value                 | double precision  | 

indexes source_id, टाइमस्टैम्प और टाइमस्टैम्प और आईडी के कॉम्बो पर मौजूद हैं ( CREATE INDEX timeseries_id_timestamp_combo_idx ON timeseries (id, timeseries DESC NULLS LAST))

इसमें 20M पंक्तियां हैं (ठीक है, 120M है, लेकिन source_id = 1) के साथ 20M है। इसमें timestampभिन्नता के साथ समान के लिए कई प्रविष्टियां हैं observation_timestamp, जो रिपोर्ट की गई या देखी valueगई बातों का वर्णन timestampकरती हैं observation_timestamp। उदाहरण के लिए तापमान का अनुमान कल दोपहर 2 बजे लगाया गया था जैसा कि आज 12 बजे भविष्यवाणी की गई है।

आदर्श रूप से यह तालिका कुछ चीजों को अच्छी तरह से करती है:

• नई प्रविष्टियाँ डालने वाला बैच, कभी-कभी एक समय में 100K
• टाइमर के लिए देखे गए डेटा का चयन करना ("जनवरी तक मार्च के लिए तापमान की भविष्यवाणी क्या है")
• एक निश्चित बिंदु से देखे गए टाइमर के लिए देखे गए डेटा का चयन करना ("मार्च के लिए जनवरी तक के तापमान अनुमानों का क्या विचार है जैसा कि हमने 1 नवंबर को सोचा था")

दूसरा एक वह है जो इस सवाल का केंद्र है।

तालिका में डेटा निम्न की तरह दिखाई देगा

id  source_id   timestamp   observation_timestamp   value
1   1           1531084900  1531083900              9999
2   1           1531084900  1531082900              1111
3   1           1531085900  1531083900              8888
4   1           1531085900  1531082900              7777
5   1           1531086900  1531082900              5555

और क्वेरी का एक आउटपुट निम्नलिखित की तरह दिखेगा (केवल नवीनतम अवलोकन_टिमस्टैम्प की पंक्ति को दर्शाया गया है)

id  source_id   timestamp   observation_timestamp   value
1   1           1531084900  1531083900              9999
3   1           1531085900  1531083900              8888
5   1           1531086900  1531082900              5555

मैंने पहले से ही इन प्रश्नों को अनुकूलित करने के लिए कुछ सामग्री से परामर्श किया है, अर्थात्

• /programming/25536422/optimize-group-by-query-to-retrieve-latest-record-per-user/25536748#25536748
• PostgreSQL में तेजी से DISTINCT कैसे करें?
• /programming/3800551/select-first-row-in-each-group-by-group

... सीमित सफलता के साथ।

मैंने इसके साथ एक अलग तालिका बनाने पर विचार timestampकिया है ताकि यह बाद के संदर्भ में आसान हो, लेकिन उन लोगों की अपेक्षाकृत उच्च कार्डिनैलिटी के कारण मुझे संदेह है कि क्या वे मेरी मदद करेंगे - इसके अलावा मुझे चिंता है कि यह पूरा करने में बाधा होगी batch inserting new entries।

---

मैं तीन प्रश्नों को देख रहा हूं, और वे सभी मुझे खराब प्रदर्शन दे रहे हैं

• LATERAL के साथ पुनरावर्ती CTE सम्मिलित हों
• विंडो फ़ंक्शन
• DISTINCT ON

(मुझे पता है कि वे इस समय एक ही काम नहीं करते हैं, लेकिन जहाँ तक मैं देख रहा हूँ, वे क्वेरी के प्रकार के अच्छे चित्रण के रूप में काम करते हैं।)

LATERAL के साथ पुनरावर्ती CTE सम्मिलित हों

WITH RECURSIVE cte AS (
    (
        SELECT ts
        FROM timeseries ts
        WHERE source_id = 1
        ORDER BY id, "timestamp" DESC NULLS LAST
        LIMIT 1
    )
    UNION ALL
    SELECT (
        SELECT ts1
        FROM timeseries ts1
        WHERE id > (c.ts).id
        AND source_id = 1
        ORDER BY id, "timestamp" DESC NULLS LAST
        LIMIT 1
    )
    FROM cte c
    WHERE (c.ts).id IS NOT NULL
)
SELECT (ts).*
FROM cte
WHERE (ts).id IS NOT NULL
ORDER BY (ts).id;

प्रदर्शन:

Sort  (cost=164999681.98..164999682.23 rows=100 width=28)
  Sort Key: ((cte.ts).id)
  CTE cte
    ->  Recursive Union  (cost=1653078.24..164999676.64 rows=101 width=52)
          ->  Subquery Scan on *SELECT* 1  (cost=1653078.24..1653078.26 rows=1 width=52)
                ->  Limit  (cost=1653078.24..1653078.25 rows=1 width=60)
                      ->  Sort  (cost=1653078.24..1702109.00 rows=19612304 width=60)
                            Sort Key: ts.id, ts.timestamp DESC NULLS LAST
                            ->  Bitmap Heap Scan on timeseries ts  (cost=372587.92..1555016.72 rows=19612304 width=60)
                                  Recheck Cond: (source_id = 1)
                                  ->  Bitmap Index Scan on ix_timeseries_source_id  (cost=0.00..367684.85 rows=19612304 width=0)
                                        Index Cond: (source_id = 1)
          ->  WorkTable Scan on cte c  (cost=0.00..16334659.64 rows=10 width=32)
                Filter: ((ts).id IS NOT NULL)
                SubPlan 1
                  ->  Limit  (cost=1633465.94..1633465.94 rows=1 width=60)
                        ->  Sort  (cost=1633465.94..1649809.53 rows=6537435 width=60)
                              Sort Key: ts1.id, ts1.timestamp DESC NULLS LAST
                              ->  Bitmap Heap Scan on timeseries ts1  (cost=369319.21..1600778.77 rows=6537435 width=60)
                                    Recheck Cond: (source_id = 1)
                                    Filter: (id > (c.ts).id)
                                    ->  Bitmap Index Scan on ix_timeseries_source_id  (cost=0.00..367684.85 rows=19612304 width=0)
                                          Index Cond: (source_id = 1)
  ->  CTE Scan on cte  (cost=0.00..2.02 rows=100 width=28)
        Filter: ((ts).id IS NOT NULL)

(केवल EXPLAIN, EXPLAIN ANALYZEपूरा नहीं कर सकता, लिया> 24 घंटे क्वेरी को पूरा करने के लिए)

विंडो फ़ंक्शन

WITH summary AS (
  SELECT ts.id, ts.source_id, ts.value,
    ROW_NUMBER() OVER(PARTITION BY ts.timestamp ORDER BY ts.observation_timestamp DESC) AS rn
  FROM timeseries ts
  WHERE source_id = 1
)
SELECT s.*
FROM summary s
WHERE s.rn = 1;

प्रदर्शन:

CTE Scan on summary s  (cost=5530627.97..5971995.66 rows=98082 width=24) (actual time=150368.441..226331.286 rows=88404 loops=1)
  Filter: (rn = 1)
  Rows Removed by Filter: 20673704
  CTE summary
    ->  WindowAgg  (cost=5138301.13..5530627.97 rows=19616342 width=32) (actual time=150368.429..171189.504 rows=20762108 loops=1)
          ->  Sort  (cost=5138301.13..5187341.98 rows=19616342 width=24) (actual time=150368.405..165390.033 rows=20762108 loops=1)
                Sort Key: ts.timestamp, ts.observation_timestamp DESC
                Sort Method: external merge  Disk: 689752kB
                ->  Bitmap Heap Scan on timeseries ts  (cost=372675.22..1555347.49 rows=19616342 width=24) (actual time=2767.542..50399.741 rows=20762108 loops=1)
                      Recheck Cond: (source_id = 1)
                      Rows Removed by Index Recheck: 217784
                      Heap Blocks: exact=48415 lossy=106652
                      ->  Bitmap Index Scan on ix_timeseries_source_id  (cost=0.00..367771.13 rows=19616342 width=0) (actual time=2757.245..2757.245 rows=20762630 loops=1)
                            Index Cond: (source_id = 1)
Planning time: 0.186 ms
Execution time: 234883.090 ms

DISTINCT ON

SELECT DISTINCT ON (timestamp) *
FROM timeseries
WHERE source_id = 1
ORDER BY timestamp, observation_timestamp DESC;

प्रदर्शन:

Unique  (cost=5339449.63..5437531.34 rows=15991 width=28) (actual time=112653.438..121397.944 rows=88404 loops=1)
  ->  Sort  (cost=5339449.63..5388490.48 rows=19616342 width=28) (actual time=112653.437..120175.512 rows=20762108 loops=1)
        Sort Key: timestamp, observation_timestamp DESC
        Sort Method: external merge  Disk: 770888kB
        ->  Bitmap Heap Scan on timeseries  (cost=372675.22..1555347.49 rows=19616342 width=28) (actual time=2091.585..56109.942 rows=20762108 loops=1)
              Recheck Cond: (source_id = 1)
              Rows Removed by Index Recheck: 217784
              Heap Blocks: exact=48415 lossy=106652
              ->  Bitmap Index Scan on ix_timeseries_source_id  (cost=0.00..367771.13 rows=19616342 width=0) (actual time=2080.054..2080.054 rows=20762630 loops=1)
                    Index Cond: (source_id = 1)
Planning time: 0.132 ms
Execution time: 161651.006 ms

---

मुझे अपना डेटा कैसे संरचित करना चाहिए, क्या ऐसे स्कैन हैं जो वहां नहीं होने चाहिए, क्या इन प्रश्नों को आम तौर पर ~ 1s (~ 120 के बजाय) करना संभव है?

क्या मेरे द्वारा वांछित परिणाम प्राप्त करने के लिए डेटा को क्वेरी करने का एक अलग तरीका है?

यदि नहीं, तो मुझे किस आधारभूत संरचना / वास्तुकला को देखना चाहिए?

Comments

आप जो चाहते हैं वह एक ढीला-सूचकांक स्कैन या स्किप स्कैन है। वे जल्द ही आ रहे हैं। आप पैच को अब लागू कर सकते हैं यदि आप इसके साथ पोस्ट करना चाहते हैं postgresql-archive.org/Index-Skip-Scan-td6025532.html यह मुश्किल से एक महीने पुराना है = पी

— इवान कैरोल

Livin 'किनारे पर @ EvanCarroll = P - यह मेरे लिए बहुत जल्दी लगता है, मैं अजुर पर पोस्टग्रेज का उपयोग नहीं कर रहा हूं, यह भी विचार करने योग्य नहीं है।

— पेपीजन स्कोन

कृपया LITITs के बिना विस्तृत योजना दिखाएं (क्योंकि जो कि अनुकूलित करने की आवश्यकता है), लेकिन उन परिवर्तनों के साथ जिन्हें मैंने अपने पहले उत्तर में सुझाया था। लेकिन लिमिट्स के बिना, मुझे लगता है कि आप ~ 1 एस में काम करने की असंभव राशि के लिए पूछ रहे हैं। हो सकता है कि आप कुछ सामान पहले से तैयार कर लें।

— जेजे

@jjanes बिल्कुल - सुझाव के लिए धन्यवाद। मैंने LIMITअब सवाल से हटा दिया है , और EXPLAIN ANALYZEकेवल ( हालांकि भाग EXPLAINपर recursive) के साथ आउटपुट जोड़ा

— पेपीजन स्कोन

Answer 1

आपकी पुनरावर्ती CTE क्वेरी के साथ, अंतिम ORDER BY (ts).idअनावश्यक है क्योंकि CTE स्वचालित रूप से उन्हें उसी क्रम में बनाता है। इसे हटाकर क्वेरी को बहुत तेज़ करना चाहिए, यह केवल 20,180,572 पंक्तियों को उत्पन्न करने के बजाय जल्दी से रोक सकती है, बल्कि सभी को 500 से दूर फेंक सकती है। साथ ही, सूचकांक के निर्माण में (source_id, id, timestamp desc nulls last)इसे और सुधार करना चाहिए।

अन्य दो प्रश्नों के लिए, work_mem को बढ़ाने से मेमोरी में बिटमैप्स फिट हो जाते हैं (हानिपूर्ण ढेर ब्लॉकों से छुटकारा पाने में) कुछ मदद मिलेगी। लेकिन कस्टम इंडेक्स के रूप में ज्यादा नहीं, जैसे कि (source_id, "timestamp", observation_timestamp DESC)या केवल इंडेक्स के लिए बेहतर स्कैन करता है (source_id, "timestamp", observation_timestamp DESC, value, id)।

Comments

सुझाव के लिए धन्यवाद - मैं निश्चित रूप से कस्टम अनुक्रमण में देखूंगा जैसे आप सुझाव देते हैं। LIMIT 500मुझे उत्पादन को सीमित करने के लिए गया था, लेकिन उत्पादन कोड में ऐसा नहीं होता है। मैं यह दर्शाने के लिए अपनी पोस्ट संपादित करूंगा।

— पेपीजन स्कोन

लिमिट की अनुपस्थिति में, अनुक्रमणिका बहुत कम प्रभावी हो सकती है। लेकिन फिर भी एक कोशिश के काबिल है।

— जेजे

आप सही हैं - LIMITऔर आपके सुझावों के साथ, वर्तमान में निष्पादन है 356.482 ms( Index Scan using ix_timeseries_source_id_timestamp_observation_timestamp on timeseries (cost=0.57..62573201.42 rows=18333374 width=28) (actual time=174.098..356.097 rows=2995 loops=1)) लेकिन इसके बिना LIMITयह पहले जैसा है। मैं Index Scanउस स्थिति में भी कैसे लाभ उठाऊंगा और नहीं Bitmap Index/Heap Scan?

— पेपीजन स्कोन