PK ഇല്ലാതെ ഒരു ടേബിളിൽ നിന്ന് ക്ലിയർ റെക്കോർഡുകൾ മായ്‌ക്കുന്നു

എപ്പോൾ സാഹചര്യങ്ങളുണ്ട് പ്രാഥമിക കീ ഇല്ലാത്ത ഒരു മേശയിലേക്ക് അല്ലെങ്കിൽ മറ്റേതെങ്കിലും അദ്വിതീയ സൂചിക, ഒരു മേൽനോട്ടം കാരണം, ഇതിനകം നിലവിലുള്ള റെക്കോർഡുകളുടെ പൂർണ്ണമായ ക്ലോണുകൾ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.

ഉദാഹരണത്തിന്, ഒരു ക്രോണോളജിക്കൽ മെട്രിക്കിൻ്റെ മൂല്യങ്ങൾ ഒരു കോപ്പി സ്ട്രീം ഉപയോഗിച്ച് PostgreSQL-ൽ എഴുതിയിരിക്കുന്നു, തുടർന്ന് പെട്ടെന്ന് ഒരു പരാജയം സംഭവിക്കുകയും പൂർണ്ണമായും സമാനമായ ഡാറ്റയുടെ ഒരു ഭാഗം വീണ്ടും എത്തുകയും ചെയ്യുന്നു.

അനാവശ്യമായ ക്ലോണുകളുടെ ഡാറ്റാബേസ് എങ്ങനെ ഒഴിവാക്കാം?

സഹായി അല്ലാത്തപ്പോൾ പി.കെ

അത്തരമൊരു സാഹചര്യം ആദ്യം ഉണ്ടാകുന്നത് തടയുക എന്നതാണ് ഏറ്റവും എളുപ്പമുള്ള മാർഗം. ഉദാഹരണത്തിന്, റോൾ പ്രൈമറി കീ. എന്നാൽ സംഭരിച്ച ഡാറ്റയുടെ അളവ് വർദ്ധിപ്പിക്കാതെ ഇത് എല്ലായ്പ്പോഴും സാധ്യമല്ല.

ഉദാഹരണത്തിന്, ഉറവിട സിസ്റ്റത്തിൻ്റെ കൃത്യത ഡാറ്റാബേസിലെ ഫീൽഡിൻ്റെ കൃത്യതയേക്കാൾ കൂടുതലാണെങ്കിൽ:

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 എന്നതിനുപകരം കൗണ്ട്ഡൗൺ ഒരു സെക്കൻഡ് മുമ്പ് ഡാറ്റാബേസിൽ രേഖപ്പെടുത്തിയിട്ടുണ്ട്, പക്ഷേ ഒരു ആപ്ലിക്കേഷൻ വീക്ഷണകോണിൽ നിന്ന് തികച്ചും സാധുവായി തുടർന്നു (എല്ലാത്തിനുമുപരി, ഡാറ്റ മൂല്യങ്ങൾ വ്യത്യസ്തമാണ്!).

തീർച്ചയായും നിങ്ങൾക്കത് ചെയ്യാൻ കഴിയും പികെ(മെട്രിക്, ടിഎസ്) - എന്നാൽ സാധുവായ ഡാറ്റയ്‌ക്കായി ഞങ്ങൾക്ക് ഉൾപ്പെടുത്തൽ വൈരുദ്ധ്യങ്ങൾ ലഭിക്കും.

ചെയ്യാന് കഴിയും 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 മുഖേന അഭിസംബോധന ചെയ്യുന്നു, ഒരു നിർദ്ദിഷ്ട റെക്കോർഡിൻ്റെ ഫിസിക്കൽ ഐഡൻ്റിഫയർ.

അതായത്, ഒന്നാമതായി, പട്ടിക വരിയുടെ പൂർണ്ണമായ ഉള്ളടക്കത്തിൻ്റെ പശ്ചാത്തലത്തിൽ ഞങ്ങൾ റെക്കോർഡുകളുടെ 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 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[]);

നമുക്ക് സ്വയം പരിശോധിക്കാം:

[explain.tensor.ru-ൽ കാണുക]

അതെ, എല്ലാം ശരിയാണ്: ഞങ്ങളുടെ 3 റെക്കോർഡുകൾ മുഴുവൻ ടേബിളിലെയും ഒരേയൊരു Seq സ്കാനിനായി തിരഞ്ഞെടുത്തു, കൂടാതെ ഡാറ്റ തിരയാൻ ഡിലീറ്റ് നോഡ് ഉപയോഗിച്ചു ടിഡ് സ്കാനോടുകൂടിയ ഒറ്റ പാസ്:

->  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;

[explain.tensor.ru-ൽ കാണുക]

അതിനാൽ, രീതി വിജയകരമായി പ്രവർത്തിക്കുന്നു, പക്ഷേ ഇത് കുറച്ച് ജാഗ്രതയോടെ ഉപയോഗിക്കണം. കാരണം ഡിലീറ്റ് ചെയ്യുന്ന ഓരോ റെക്കോർഡിനും ടിഡ് സ്കാനിൽ ഒരു ഡാറ്റ പേജും ഡിലീറ്റ് എന്നതിൽ ഒന്നുമാണ്.

അവലംബം: www.habr.com