🥇PK शिवाय टेबलवरून क्लोन रेकॉर्ड साफ करणे

अशा परिस्थिती असतात जेव्हा प्राथमिक की नसलेल्या टेबलमध्ये किंवा इतर कोणत्याही अद्वितीय निर्देशांकात, चुकीमुळे, आधीच अस्तित्वात असलेल्या नोंदींचे संपूर्ण क्लोन असतात.

PK शिवाय टेबलमधून क्लोन रेकॉर्ड साफ करणे

उदाहरणार्थ, कालक्रमानुसार मेट्रिकची मूल्ये COPY स्ट्रीम वापरून PostgreSQL वर लिहिली जातात आणि नंतर अचानक बिघाड होतो आणि काही पूर्णपणे एकसारखा डेटा पुन्हा येतो.

डेटाबेसमधून अनावश्यक क्लोन कसे काढून टाकायचे?

जेव्हा पीके उपयुक्त नसतो

सर्वात सोपा उपाय म्हणजे ही परिस्थिती सुरुवातीलाच उद्भवू नये. उदाहरणार्थ, PRIMARY KEY लागू करून. परंतु साठवलेल्या डेटाचे प्रमाण वाढवल्याशिवाय हे नेहमीच शक्य नसते.

उदाहरणार्थ, जर स्त्रोत प्रणालीची अचूकता डेटाबेसमधील फील्डच्या अचूकतेपेक्षा जास्त असेल तर:

metric   | ts                  | data
--------------------------------------------------
cpu.busy | 2019-12-20 00:00:00 | {"value" : 12.34}
cpu.busy | 2019-12-20 00:00:01 | {"value" : 10}
cpu.busy | 2019-12-20 00:00:01 | {"value" : 11.2}
cpu.busy | 2019-12-20 00:00:03 | {"value" : 15.7}

लक्षात आले का? 00:00:02 ऐवजी, काउंटडाउन एका सेकंदापूर्वी ts डेटाबेसमध्ये रेकॉर्ड केले गेले होते, परंतु व्यावहारिक दृष्टिकोनातून ते पूर्णपणे वैध राहिले (शेवटी, डेटा मूल्ये भिन्न आहेत!).

अर्थात, ते करता येते पीके(मेट्रिक, टीएस) — पण नंतर आपल्याला वैध डेटासाठी इन्सर्शन संघर्ष मिळतील.

करू शकतो पीके(मेट्रिक, टीएस, डेटा) - पण यामुळे त्याचे प्रमाण खूप वाढेल, जे आपण वापरणार नाही.

म्हणून, सर्वात योग्य पर्याय म्हणजे नियमित नॉन-युनिक इंडेक्स तयार करणे. (मेट्रिक, टीएस) आणि जर समस्या उद्भवल्या तर त्या सोडवा.

क्लोन युद्धे सुरू झाली आहेत.

काही प्रकारचा अपघात झाला, आणि आता आपल्याला टेबलवरील क्लोन रेकॉर्ड नष्ट करावे लागतील.

PK शिवाय टेबलमधून क्लोन रेकॉर्ड साफ करणे

चला सुरुवातीच्या डेटाचे अनुकरण करूया:

CREATE TABLE tbl(k text, v integer);

INSERT INTO tbl
VALUES
  ('a', 1)
, ('a', 3)
, ('b', 2)
, ('b', 2) -- oops!
, ('c', 3)
, ('c', 3) -- oops!!
, ('c', 3) -- oops!!
, ('d', 4)
, ('e', 5)
;

इथे आपला हात तीन वेळा हलला, Ctrl+V अडकले, आणि हे बघा...

प्रथम, आपण हे समजून घेऊया की आपले टेबल बरेच मोठे असू शकते, म्हणून आपल्याला सर्व क्लोन सापडल्यानंतर, ते हटविण्यासाठी आपल्याला अक्षरशः "बोट लावावे लागेल". विशिष्ट नोंदी पुन्हा न शोधता.

आणि असा एक मार्ग आहे - हा आहे सीटीआयडी अॅड्रेसिंग, विशिष्ट रेकॉर्डचा भौतिक ओळखकर्ता.

तर, सर्वप्रथम, आपल्याला टेबलच्या पंक्तीच्या संपूर्ण मजकुरावर आधारित रेकॉर्डचे CTID गोळा करावे लागतील. सर्वात सोपा पर्याय म्हणजे संपूर्ण पंक्ती मजकूरात कास्ट करणे:

SELECT
  T::text
, array_agg(ctid) ctids
FROM
  tbl T
GROUP BY
  1;

t     | ctids
---------------------------------
(e,5) | {"(0,9)"}
(d,4) | {"(0,8)"}
(c,3) | {"(0,5)","(0,6)","(0,7)"}
(b,2) | {"(0,3)","(0,4)"}
(a,3) | {"(0,2)"}
(a,1) | {"(0,1)"}

कास्ट न करणे शक्य आहे का?तत्वतः, बहुतेक प्रकरणांमध्ये हे शक्य आहे. जोपर्यंत तुम्ही या टेबलमधील फील्ड वापरण्यास सुरुवात करत नाही तोपर्यंत समानता नसलेले ऑपरेटर प्रकार:

CREATE TABLE tbl(k text, v integer, x point);
SELECT
  array_agg(ctid) ctids
FROM
  tbl T
GROUP BY
  T;
-- ERROR:  could not identify an equality operator for type tbl

अहाहा, आपल्याला लगेच दिसून येते की जर अ‍ॅरेमध्ये एकापेक्षा जास्त एंट्री असतील तर ते सर्व क्लोन आहेत. चला फक्त तेच ठेवूया:

SELECT
  unnest(ctids[2:])
FROM
  (
    SELECT
      array_agg(ctid) ctids
    FROM
      tbl T
    GROUP BY
      T::text
  ) T;

unnest
------
(0,6)
(0,7)
(0,4)

ज्यांना लहान लिहायला आवडते त्यांच्यासाठीतुम्ही ते असे देखील लिहू शकता:

SELECT
  unnest((array_agg(ctid))[2:])
FROM
  tbl T
GROUP BY
  T::text;

आम्हाला सिरीयलाइज्ड स्ट्रिंगच्या व्हॅल्यूमध्ये रस नसल्यामुळे, आम्ही ते सबक्वेरीच्या परत आलेल्या कॉलममधून वगळले.

आम्हाला मिळालेल्या संचाचा वापर DELETE ला करायला लावणे एवढेच उरले आहे:

DELETE FROM
  tbl
WHERE
  ctid = ANY(ARRAY(
    SELECT
      unnest(ctids[2:])
    FROM
      (
        SELECT
          array_agg(ctid) ctids
        FROM
          tbl T
        GROUP BY
          T::text
      ) T
  )::tid[]);

चला स्वतःची तपासणी करूया:

PK शिवाय टेबलमधून क्लोन रेकॉर्ड साफ करणे
[explain.tensor.ru पहा]

हो, बरोबर आहे: आमचे ३ रेकॉर्ड संपूर्ण टेबलच्या एकाच Seq स्कॅनमध्ये निवडले गेले होते आणि डेटा शोधण्यासाठी Delete नोड वापरला गेला होता. टिड स्कॅनसह सिंगल पास:

->  Tid Scan on tbl (actual time=0.050..0.051 rows=3 loops=1)
      TID Cond: (ctid = ANY ($0))

जर तुम्ही बरेच रेकॉर्ड साफ केले तर, व्हॅक्यूम अॅनालिझ चालवायला विसरू नका..

चला मोठ्या टेबलसाठी आणि जास्त डुप्लिकेटसह तपासूया:

TRUNCATE TABLE tbl;

INSERT INTO tbl
SELECT
  chr(ascii('a'::text) + (random() * 26)::integer) k -- a..z
, (random() * 100)::integer v -- 0..99
FROM
  generate_series(1, 10000) i;

PK शिवाय टेबलमधून क्लोन रेकॉर्ड साफ करणे
[explain.tensor.ru पहा]

म्हणून, ही पद्धत यशस्वीरित्या कार्य करते, परंतु ती काही सावधगिरीने वापरली पाहिजे. कारण प्रत्येक डिलीट केलेल्या रेकॉर्डसाठी, टिड स्कॅनमध्ये एक डेटा पेज वाचला जातो आणि डिलीटमध्ये एक.

स्त्रोत: www.habr.com