PK ਤੋਂ ਬਿਨਾਂ ਟੇਬਲ ਤੋਂ ਕਲੋਨ ਰਿਕਾਰਡ ਕਲੀਅਰ ਕਰਨਾ

ਅਜਿਹੀਆਂ ਸਥਿਤੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਜਦੋਂ ਪ੍ਰਾਇਮਰੀ ਕੁੰਜੀ ਤੋਂ ਬਿਨਾਂ ਇੱਕ ਟੇਬਲ ਤੇ ਜਾਂ ਕੁਝ ਹੋਰ ਵਿਲੱਖਣ ਸੂਚਕਾਂਕ, ਇੱਕ ਨਿਗਰਾਨੀ ਦੇ ਕਾਰਨ, ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ ਰਿਕਾਰਡਾਂ ਦੇ ਪੂਰੇ ਕਲੋਨ ਸ਼ਾਮਲ ਕੀਤੇ ਗਏ ਹਨ।

ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਕਾਲਕ੍ਰਮਿਕ ਮੈਟ੍ਰਿਕ ਦੇ ਮੁੱਲ ਇੱਕ COPY ਸਟ੍ਰੀਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ 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 ਦੀ ਬਜਾਏ ਕਾਊਂਟਡਾਊਨ ਇੱਕ ਸਕਿੰਟ ਪਹਿਲਾਂ ts ਦੇ ਨਾਲ ਡੇਟਾਬੇਸ ਵਿੱਚ ਰਿਕਾਰਡ ਕੀਤਾ ਗਿਆ ਸੀ, ਪਰ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ ਕਾਫ਼ੀ ਵੈਧ ਰਿਹਾ (ਆਖ਼ਰਕਾਰ, ਡੇਟਾ ਦੇ ਮੁੱਲ ਵੱਖਰੇ ਹਨ!)

ਬੇਸ਼ੱਕ ਤੁਸੀਂ ਇਹ ਕਰ ਸਕਦੇ ਹੋ PK(ਮੈਟ੍ਰਿਕ, ts) - ਪਰ ਫਿਰ ਸਾਨੂੰ ਵੈਧ ਡੇਟਾ ਲਈ ਸੰਮਿਲਨ ਵਿਵਾਦ ਪ੍ਰਾਪਤ ਹੋਣਗੇ।

ਕਰ ਸਕਦਾ ਹੈ PK(ਮੈਟ੍ਰਿਕ, ts, ਡੇਟਾ) - ਪਰ ਇਹ ਇਸਦੇ ਵਾਲੀਅਮ ਨੂੰ ਬਹੁਤ ਵਧਾ ਦੇਵੇਗਾ, ਜਿਸਦੀ ਅਸੀਂ ਵਰਤੋਂ ਨਹੀਂ ਕਰਾਂਗੇ.

ਇਸ ਲਈ, ਸਭ ਤੋਂ ਸਹੀ ਵਿਕਲਪ ਨਿਯਮਤ ਗੈਰ-ਵਿਲੱਖਣ ਸੂਚਕਾਂਕ ਬਣਾਉਣਾ ਹੈ (ਮੈਟ੍ਰਿਕ, ts) ਅਤੇ ਇਸ ਤੱਥ ਤੋਂ ਬਾਅਦ ਸਮੱਸਿਆਵਾਂ ਨਾਲ ਨਜਿੱਠੋ ਜੇਕਰ ਉਹ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ।

"ਕਲੋਨਿਕ ਯੁੱਧ ਸ਼ੁਰੂ ਹੋ ਗਿਆ ਹੈ"

ਕਿਸੇ ਕਿਸਮ ਦਾ ਹਾਦਸਾ ਵਾਪਰਿਆ, ਅਤੇ ਹੁਣ ਸਾਨੂੰ ਟੇਬਲ ਤੋਂ ਕਲੋਨ ਰਿਕਾਰਡ ਨੂੰ ਨਸ਼ਟ ਕਰਨਾ ਪਏਗਾ.

ਆਉ ਅਸਲੀ ਡੇਟਾ ਦਾ ਮਾਡਲ ਕਰੀਏ:

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 ਕਰੋ:

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[]);

ਆਓ ਆਪਣੇ ਆਪ ਦੀ ਜਾਂਚ ਕਰੀਏ:

[explanation.tensor.ru 'ਤੇ ਦੇਖੋ]

ਹਾਂ, ਸਭ ਕੁਝ ਸਹੀ ਹੈ: ਸਾਡੇ 3 ਰਿਕਾਰਡ ਪੂਰੇ ਸਾਰਣੀ ਦੇ ਸਿਰਫ ਸੇਕ ਸਕੈਨ ਲਈ ਚੁਣੇ ਗਏ ਸਨ, ਅਤੇ ਮਿਟਾਓ ਨੋਡ ਦੀ ਵਰਤੋਂ ਡੇਟਾ ਦੀ ਖੋਜ ਲਈ ਕੀਤੀ ਗਈ ਸੀ ਟਿਡ ਸਕੈਨ ਨਾਲ ਸਿੰਗਲ ਪਾਸ:

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

[explanation.tensor.ru 'ਤੇ ਦੇਖੋ]

ਇਸ ਲਈ, ਵਿਧੀ ਸਫਲਤਾਪੂਰਵਕ ਕੰਮ ਕਰਦੀ ਹੈ, ਪਰ ਇਸਨੂੰ ਕੁਝ ਸਾਵਧਾਨੀ ਨਾਲ ਵਰਤਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ. ਕਿਉਂਕਿ ਮਿਟਾਏ ਜਾਣ ਵਾਲੇ ਹਰੇਕ ਰਿਕਾਰਡ ਲਈ, ਟਿਡ ਸਕੈਨ ਵਿੱਚ ਇੱਕ ਡੇਟਾ ਪੇਜ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਮਿਟਾਓ ਵਿੱਚ।

ਸਰੋਤ: www.habr.com