PK વગરના ટેબલમાંથી ક્લોન રેકોર્ડ્સ સાફ કરવું

એવી પરિસ્થિતિઓ છે જ્યારે પ્રાથમિક કી વગરના ટેબલ પર અથવા અમુક અન્ય અનન્ય અનુક્રમણિકા, દેખરેખને કારણે, પહેલાથી અસ્તિત્વમાં છે તેવા રેકોર્ડ્સના સંપૂર્ણ ક્લોન્સનો સમાવેશ થાય છે.

ઉદાહરણ તરીકે, કાલક્રમિક મેટ્રિકના મૂલ્યો પોસ્ટગ્રેએસક્યુએલમાં કોપી સ્ટ્રીમનો ઉપયોગ કરીને લખવામાં આવે છે, અને પછી અચાનક નિષ્ફળતા આવે છે, અને સંપૂર્ણપણે સમાન ડેટાનો ભાગ ફરીથી આવે છે.

બિનજરૂરી ક્લોન્સના ડેટાબેઝથી કેવી રીતે છુટકારો મેળવવો?

જ્યારે પીકે મદદગાર નથી

આવી પરિસ્થિતિને પ્રથમ સ્થાને બનતા અટકાવવાનો સૌથી સહેલો રસ્તો છે. ઉદાહરણ તરીકે, પ્રાથમિક કી રોલ કરો. પરંતુ સંગ્રહિત ડેટાના વોલ્યુમમાં વધારો કર્યા વિના આ હંમેશા શક્ય નથી.

ઉદાહરણ તરીકે, જો સ્રોત સિસ્ટમની ચોકસાઈ ડેટાબેઝમાંના ક્ષેત્રની ચોકસાઈ કરતા વધારે છે:

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

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

[explan.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;

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

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

સોર્સ: www.habr.com