ការសម្អាតកំណត់ត្រាក្លូនពីតារាងដោយគ្មាន PK

មានស្ថានភាពនៅពេល ទៅតារាងដោយគ្មានសោចម្បង ឬលិបិក្រមពិសេសមួយចំនួនផ្សេងទៀត ដោយសារតែការត្រួតពិនិត្យ ក្លូនពេញលេញនៃកំណត់ត្រាដែលមានស្រាប់ត្រូវបានរួមបញ្ចូល។

ឧទាហរណ៍ តម្លៃនៃម៉ែត្រកាលប្បវត្តិត្រូវបានសរសេរទៅក្នុង PostgreSQL ដោយប្រើស្ទ្រីមចម្លង ហើយបន្ទាប់មកមានការបរាជ័យភ្លាមៗ ហើយផ្នែកនៃទិន្នន័យដូចគ្នាទាំងស្រុងនឹងមកដល់ម្តងទៀត។

តើធ្វើដូចម្តេចដើម្បីកម្ចាត់មូលដ្ឋានទិន្នន័យនៃក្លូនដែលមិនចាំបាច់?

នៅពេលដែល PK មិនមែនជាជំនួយការ

មធ្យោបាយងាយស្រួលបំផុតគឺការពារស្ថានភាពបែបនេះកុំឱ្យកើតឡើងនៅកន្លែងដំបូង។ ឧទាហរណ៍ រំកិល 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, ទិន្នន័យ) - ប៉ុន្តែវានឹងបង្កើនបរិមាណរបស់វាយ៉ាងខ្លាំង ដែលយើងនឹងមិនប្រើ។

ដូច្នេះ ជម្រើសត្រឹមត្រូវបំផុតគឺបង្កើតលិបិក្រមដែលមិនមានតែមួយគត់ធម្មតា។ (ម៉ែត្រ, 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[]);

តោះពិនិត្យមើលខ្លួនយើង៖

[សូមមើលពន្យល់.tensor.ru]

បាទ អ្វីគ្រប់យ៉ាងគឺត្រឹមត្រូវ៖ កំណត់ត្រា 3 របស់យើងត្រូវបានជ្រើសរើសសម្រាប់ការស្កេន Seq តែមួយគត់នៃតារាងទាំងមូល ហើយថ្នាំងលុបត្រូវបានប្រើដើម្បីស្វែងរកទិន្នន័យ ឆ្លងកាត់តែមួយជាមួយ Tid Scan:

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

[សូមមើលពន្យល់.tensor.ru]

ដូច្នេះ វិធីសាស្ត្រ​នេះ​ដំណើរការ​ដោយ​ជោគជ័យ ប៉ុន្តែ​វា​ត្រូវតែ​ប្រើ​ដោយ​ប្រយ័ត្នប្រយែង។ ដោយសារតែរាល់កំណត់ត្រាដែលត្រូវបានលុប មានទំព័រទិន្នន័យមួយបានអាននៅក្នុង Tid Scan ហើយមួយទៀតនៅក្នុង Delete ។

ប្រភព: www.habr.com