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(મેટ્રિક, ts) — પણ પછી આપણને માન્ય ડેટા માટે નિવેશ વિરોધાભાસ મળશે.

કરી શકવુ PK(મેટ્રિક, 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 એકત્રિત કરવાની જરૂર છે. સૌથી સરળ વિકલ્પ એ છે કે આખી પંક્તિને ટેક્સ્ટમાં કાસ્ટ કરો:

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

ચાલો આપણી જાતને ચકાસીએ:

[explan.tensor.ru પર જુઓ]

હા, તે સાચું છે: અમારા 3 રેકોર્ડ સમગ્ર કોષ્ટકના એક જ Seq સ્કેનમાં પસંદ કરવામાં આવ્યા હતા, અને ડેટા શોધવા માટે Delete નોડનો ઉપયોગ કરવામાં આવ્યો હતો. ટિડ સ્કેન સાથે સિંગલ પાસ:

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

જો તમે ઘણા બધા રેકોર્ડ સાફ કર્યા હોય, VACUUM ANALYZE ચલાવવાનું ભૂલશો નહીં..

ચાલો એક મોટું ટેબલ અને વધુ સંખ્યામાં ડુપ્લિકેટ્સ સાથે તપાસીએ:

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;

[explan.tensor.ru પર જુઓ]

તેથી, પદ્ધતિ સફળતાપૂર્વક કાર્ય કરે છે, પરંતુ તેનો ઉપયોગ થોડી સાવધાની સાથે કરવો જોઈએ. કારણ કે દરેક ડિલીટ કરેલા રેકોર્ડ માટે, Tid Scan માં એક ડેટા પેજ અને Delete માં એક ડેટા પેજ વાંચવામાં આવે છે.

સોર્સ: www.habr.com