MySQL හි නකල් දත්ත සොයා ඉවත් කිරීමේ සම්පූර්ණ මාර්ගෝපදේශය: SQL උදාහරණ සමඟ

1. හැඳින්වීම

දත්ත ගබඩාවක් ක්‍රියාත්මක කරන විට “අනුපිටපත් ලේඛන ඇතුළත් වීම” හෝ “අද්විතීය විය යුතු දත්ත බහු වාරයක් පෙනෙන්න” යන ගැටළු අසමත් නොවේ. MySQL වැනි සම්බන්ධක දත්ත ගබඩා පරිසරයන්හි, අනුපිටපත් දත්ත ලබා ගැනීම සහ කළමනාකරණය කිරීම දත්ත නිරවද්‍යතාවය සහ ගුණාත්මකභාවය රැක ගැනීමට අත්‍යවශ්‍ය කාර්යයකි.

උදාහරණයක් ලෙස, සාමාජික තොරතුරු, නිෂ්පාදන දත්ත, ඇණවුම් ඉතිහාසය වැනි මූලික ව්‍යාපාරික වගුවල, පරිශීලක දෝෂ හෝ පද්ධති දෝෂ නිසා අනුපිටපත් ලේඛන ඇතුළත් විය හැක. මෙය නොසලකා හරිනු ලැබේ නම්, එකතුව සහ විශ්ලේෂණ නිරවද්‍යතාවය අඩුවී, අනපේක්ෂිත දෝෂ හෝ මෙහෙයුම් ගැටළු ඇති විය හැක.

මෙම “අනුපිටපත් දත්ත ගැටලුව” විසඳීමට, ඔබ මුලින් කොන ලේඛන අනුපිටපත් වී ඇතිදැයි හඳුනා ගැනීම අවශ්‍ය වන අතර, පසුදා අවශ්‍යතාවය අනුව ඒ අනුපිටපත් ලේඛන සංවිධානය කිරීම හෝ ඉවත් කිරීම සිදු කළ යුතුය. නමුත් MySQL හි සාමාන්‍ය SELECT ප්‍රකාශයක් පමණක් භාවිතා කිරීම, අනුපිටපත් කාර්යක්ෂමව හඳුනා ගැනීමට සාමාන්‍යයෙන් ප්‍රමාණවත් නොවේ. ටිකක් උසස් SQL තාක්ෂණ සහ ප්‍රායෝගික ක්‍රියාමාර්ග අවශ්‍ය වේ.

මෙම ලිපියේ, අපි “MySQL හි අනුපිටපත් දත්ත ලබා ගැනීම” යන විෂයය මත අවධානය යොමු කරමින්, මූලික SQL ප්‍රකාශයන් සිට ප්‍රායෝගික යෙදුම්, කාර්යක්ෂමතා සැලකිලි, සහ පොදු දෝෂ හසුරුවීම දක්වා සියල්ල ආවරණය කරමු. ඔබ දත්ත ගබඩා ආරම්භකයෙක් හෝ දිනපතා SQL ලියන ඉංජිනේරුවෙක් වුවත්, මෙම මාර්ගෝපදේශය ප්‍රායෝගික හා ක්ෂේත්‍ර‑අධාරිත දැනුම ලබා දීමට උදව් කරයි.

2. මූලික: ප්‍රධාන තීරුවක් භාවිතා කර අනුපිටපත් හඳුනා ගැනීම

MySQL හි අනුපිටපත් දත්ත ලබා ගැනීමට ඇති අතිමහත් මූලික ක්‍රමය, “නිශ්චිත තීරුවක (ප්‍රධාන තීරුව) එකම අගය බෙදා ගන්නා බහු ලේඛන” හඳුනා ගැනීමයි. මෙම කොටසෙහි, අනුපිටපත් ප්‍රධාන අගයන් හඳුනා ගැනීමට භාවිතා කරන නියෝජිත SQL විමසුම් සහ ඒවා කෙසේ ක්‍රියා කරන්නේද යන්න පැහැදිලි කරමු.

2-1. GROUP BY සහ HAVING සමඟ අනුපිටපත් හඳුනා ගැනීම

අනුපිටපත් හඳුනා ගැනීමට මූලික තාක්ෂණය, GROUP BY වාක්‍යය භාවිතා කර ලේඛනවලට නිශ්චිත තීරුව අනුව කණ්ඩායම් කිරීම, පසුදා HAVING වාක්‍යය මගින් දෙකක් හෝ ඊට වැඩි ලේඛන අඩංගු කණ්ඩායම් පිරික්සීමයි. මෙන්න සාමාන්‍ය උදාහරණයක්:

SELECT key_column, COUNT(*) AS duplicate_count
FROM table_name
GROUP BY key_column
HAVING COUNT(*) > 1;

උදාහරණය: අනුපිටපත් සාමාජික ඊමේල් ලිපින ලබා ගැනීම

SELECT email, COUNT(*) AS count
FROM users
GROUP BY email
HAVING COUNT(*) > 1;

මෙම විමසුම ක්‍රියාත්මක කළ විට, එකම ඊමේල් ලිපිනය බහු වාරයක් ලියාපදිංචි වී ඇත්නම්, එම ඊමේල් ලිපිනය සහ අනුපිටපත් ගණන (count) ප්‍රතිඵලවල පෙන්වනු ලැබේ.

2-2. බහු තීරුවල අනුපිටපත් හඳුනා ගැනීම

දෙකක් හෝ තවත් තීරුවල සංයුතිය මත අනුපිටපත් හඳුනා ගැනීමට අවශ්‍ය නම්, ඒම තීරුවල සියල්ල GROUP BY වාක්‍යයේ සඳහන් කර, ඒම තර්කය භාවිතා කළ හැකිය.

SELECT col1, col2, COUNT(*) AS duplicate_count
FROM table_name
GROUP BY col1, col2
HAVING COUNT(*) > 1;

මෙම ක්‍රමය භාවිතා කර, “එකම සම්පූර්ණ නාමය සහ උපන් දිනය” හෝ “එකම නිෂ්පාදන අංකය සහ ඇණවුම් දිනය” වැනි බහු කොන්දේසි සම්පූර්ණයෙන් ගැලපෙන අනුපිටපත් හඳුනා ගත හැකිය.

2-3. අනුපිටපත් ලේඛන සංඛ්‍යාව ගණනය කිරීම

අනුපිටපත් පරිමාණය සමස්ත ලෙස අවබෝධ කර ගැනීමට, උපවිමසුමක් (subquery) භාවිතා කර අනුපිටපත් ලේඛන සංඛ්‍යාව ගණනය කළ හැකිය.

SELECT SUM(duplicate_count) AS total_duplicates
FROM (
  SELECT COUNT(*) AS duplicate_count
  FROM table_name
  GROUP BY key_column
  HAVING COUNT(*) > 1
) AS duplicates;

මෙම විමසුම සියලු අනුපිටපත් කණ්ඩායම් මත අනුපිටපත් ලේඛන ගණන එකතු කර ප්‍රතිඵල ලබා දේ.

GROUP BY සහ HAVING එකතු කිරීමෙන්, MySQL හි අනුපිටපත් දත්ත ලබා ගැනීම සරල හා කාර්යක්ෂම ලෙස සිදු කළ හැකිය.

3. අනුපිටපත් ප්‍රධාන අගයන් බෙදා ගන්නා සියලු ලේඛන ලබා ගැනීම

පසුගිය කොටසේ, අපි “අනුපිටපත් ප්‍රධාන අගයන්” පමණක් ලැයිස්තුගත කිරීමේ ක්‍රමය හඳුන්වා දුන්නෙමු. නමුත් වාස්තුකාර්ය ජීවිතයේ, ඔබට “නියමයෙන් කුමන ලේඛන අනුපිටපත් වී ඇතිද, ඒ සියලු විස්තර පරීක්ෂා කිරීම” අවශ්‍ය විය හැක. උදාහරණයක් ලෙස, ඔබට සම්පූර්ණ අනුපිටපත් පරිශීලක පැතිකඩ පරීක්ෂා කිරීමට හෝ අනුපිටපත් නිෂ්පාදන දත්ත පේළියෙන් පේළියට විශ්ලේෂණය කිරීමට අවශ්‍ය විය හැක.

මෙම කොටසේ, අපි අනුපිළිවෙළ යතුරු බෙදාගත් සියලු රෙකෝඩ් ලබා ගැනීමට ප්‍රායෝගික SQL රටා පැහැදිලි කරමු.

3-1. උප-විමසුමක් භාවිතයෙන් අනුපිළිවෙළ රෙකෝඩ් ලබා ගැනීම

මූලිකම ක්‍රමය වන්නේ උප-විමසුමක අනුපිළිවෙළ යතුරු අගයන්ගේ ලැයිස්තුව ලබාගෙන, එම යතුරු සමඟ ගැලපෙන සියලු රෙකෝඩ් ලබා ගැනීම.

SELECT *
FROM table_name
WHERE key_column IN (
  SELECT key_column
  FROM table_name
  GROUP BY key_column
  HAVING COUNT(*) > 1
);

උදාහරණය: අනුපිළිවෙළ ඊමේල් ලිපින සමඟ සියලු රෙකෝඩ් ලබා ගැනීම

SELECT *
FROM users
WHERE email IN (
  SELECT email
  FROM users
  GROUP BY email
  HAVING COUNT(*) > 1
);

ඔබ මෙම විමසුම ක්‍රියාත්මක කරන විට, “users” වගුවේ ඊමේල් ලිපිනය අනුපිළිවෙළ වන සියලු පේළි (ID, ලියාපදිංචි දිනය වැනි තීරුවල සමඟ) ලබා ගනී.

3-2. EXISTS භාවිතයෙන් කාර්යක්ෂම ලබා ගැනීම

ඔබට විශාල දත්ත කට්ටලයන් සමඟ කටයුතු කිරීමට හෝ කාර්ය සාධනය ගැන සැලකිල්ලට ගැනීමට අවශ්‍ය නම්, EXISTS භාවිතයද ප්‍රයෝජනවත් වේ. IN සහ EXISTS සමාන වන අතර, දත්ත ප්‍රමාණය සහ ඉන්ඩෙක්සිං පදනම්ව, එකක් අනෙකට වඩා වේගවත් විය හැක.

SELECT *
FROM table_name t1
WHERE EXISTS (
  SELECT 1
  FROM table_name t2
  WHERE t1.key_column = t2.key_column
  GROUP BY t2.key_column
  HAVING COUNT(*) > 1
);

උදාහරණය: අනුපිළිවෙළ ඊමේල් රෙකෝඩ් (EXISTS භාවිතයෙන්)

SELECT *
FROM users u1
WHERE EXISTS (
  SELECT 1
  FROM users u2
  WHERE u1.email = u2.email
  GROUP BY u2.email
  HAVING COUNT(*) > 1
);

3-3. සටහන් සහ කාර්ය සාධන සැලකිලි

• දත්ත කට්ටලය විශාල වන විට උප-විමසුම් කාර්ය සාධනය වැදගත් ලෙස බලපායි. සුදුසු ඉන්ඩෙක්සිං සමඟ, IN සහ EXISTS දෙකම ප්‍රායෝගික මට්ටමේ ක්‍රියා කරයි.
• එහෙත්, ඔබට සංකීර්ණ කොන්දේසි අවශ්‍ය නම් හෝ බහු තීරුවල අනුපිළිවෙළ තීරණය කිරීමට අවශ්‍ය නම්, විමසුම් බර වැඩිය හැක. පළමුව පරීක්ෂණ පරිසරයකදී හැසිරීම තහවුරු කරන්න.

මෙම ආකාරයෙන්, අනුපිළිවෙළ යතුරු සමඟ ගැලපෙන සියලු රෙකෝඩ් ලබා ගැනීම උප-විමසුම් හෝ EXISTS කොටස භාවිතයෙන් සිදු කළ හැක.

4. බහු තීරුවල අනුපිළිවෙළ හඳුනා ගැනීම

අනුපිළිවෙළ හඳුනා ගැනීමේ කොන්දේසි සෑම විටම එක තීරුවක් මත පදනම් නොවේ. ප්‍රායෝගිකව, බහු තීරුවල සංයෝගයක් තුළ ඒකකත්වය (uniqueness) අවශ්‍ය වීම සාමාන්‍යයයි. උදාහරණයක් ලෙස, “පූර්ණ නාමය + උපන් දිනය” ගැලපේ නම්, හෝ “නිෂ්පාදන ID + වර්ණය + ප්‍රමාණය” සියල්ල එකසේ නම්, රෙකෝඩ් අනුපිළිවෙළ ලෙස සැලකිය හැක.

මෙම කොටසේ, බහු තීරුවල අනුපිළිවෙළ ලබා ගැනීම පිළිබඳ විස්තරාත්මකව පැහැදිලි කරමු.

4-1. බහු තීරුවල GROUP BY භාවිතයෙන් අනුපිළිවෙළ හඳුනා ගැනීම

බහු තීරුවල අනුපිළිවෙළ හඳුනා ගැනීමට, GROUP BY කොටසේ තීරුවල නාමයන් කොමා (,) වලින් වෙන් කර ලැයිස්තුගත කරන්න. HAVING COUNT(*) > 1 සමඟ, දෙවරක් හෝ වැඩි වරක් පෙනෙන සංයෝගයන් පමණක් ලබා ගත හැක.

SELECT col1, col2, COUNT(*) AS duplicate_count
FROM table_name
GROUP BY col1, col2
HAVING COUNT(*) > 1;

උදාහරණය: “first_name” සහ “birthday” අනුව අනුපිළිවෙළ හඳුනා ගැනීම

SELECT first_name, birthday, COUNT(*) AS count
FROM users
GROUP BY first_name, birthday
HAVING COUNT(*) > 1;

මෙම විමසුම ඔබට “එකම නාමය” සහ “එකම උපන් දිනය” සංයෝගය බහු වරක් ලියාපදිංචි වූ අවස්ථා හඳුනා ගැනීමට උපකාරී වේ.

4-2. බහු තීරුවල අනුපිළිවෙළ යතුරු සඳහා සියලු රෙකෝඩ් ලබා ගැනීම

ඔබට අනුපිළිවෙළ යතුරු සංයෝග සඳහා සියලු රෙකෝඩ් විස්තර අවශ්‍ය නම්, උප-විමසුමක අනුපිළිවෙළ යුගල (pairs) ලබාගෙන, පසුව ඒ යුගල සමඟ ගැලපෙන සියලු පේළි ලබා ගත හැක.

SELECT *
FROM table_name t1
WHERE (col1, col2) IN (
  SELECT col1, col2
  FROM table_name
  GROUP BY col1, col2
  HAVING COUNT(*) > 1
);

උදාහරණය: “first_name” සහ “birthday” අනුපිළිවෙළ සඳහා සම්පූර්ණ රෙකෝඩ්

SELECT *
FROM users u1
WHERE (first_name, birthday) IN (
  SELECT first_name, birthday
  FROM users
  GROUP BY first_name, birthday
  HAVING COUNT(*) > 1
);

මෙම විමසුම භාවිතා කරමින්, උදාහරණයක් ලෙස “Taro Tanaka / 1990-01-01” සංයෝගය බහු වරක් ලියාපදිංචි වූ විට, ඒ සම්බන්ධ සියලු විස්තරාත්මක පේළි ලබා ගත හැක.

4-3. නිරවද්‍ය අනුපිළිවෙළ හඳුනා ගැනීම (COUNT DISTINCT)

If you want to estimate “how many rows are exact duplicates across multiple columns,” you can also use aggregation with COUNT(DISTINCT ...).

SELECT COUNT(*) - COUNT(DISTINCT col1, col2) AS duplicate_count
FROM table_name;

This SQL provides an approximate count of fully duplicated rows within the table.
මෙම SQL වගුව තුළ සම්පූර්ණයෙන්ම අනුපිටපත් වූ පේළි ගණන අනුමාන ලෙස ලබා දෙයි.

4-4. සටහන්

• බහු‑තීරු අනුපිටපත් හඳුනා ගැනීම සඳහාද, සුදුසු ඉන්ඩෙක්ස් කිරීම කුමන විමසුමක වේගය වැඩිදියුණු කරයි.
• බොහෝ තීරු ඇතුළත් වීම හෝ NULL අගයන් පවතින විට, ඔබට අනපේක්ෂිත අනුපිටපත් ප්‍රතිඵල ලැබිය හැක. ඔබේ කොන්දේසි කාරුණිකව සැලසුම් කරන්න.

In this way, detecting and extracting duplicates across multiple columns can be handled flexibly with well‑designed SQL.
මෙම ආකාරයෙන්, බහු‑තීරු අනුපිටපත් හඳුනා ගැනීම සහ එය ඉවත් කිරීම හොඳින් සැලසුම් කළ SQL මගින් සවිස්තරාත්මකව කළ හැක.

5. අනුපිටපත් ලේඛන ඉවත් කිරීම (DELETE)

Once you can extract duplicate data, the next step is deleting unnecessary duplicates. In practice, a common approach is to keep only one record among duplicates and delete the rest. However, when deleting duplicates automatically in MySQL, you must narrow down the deletion target carefully to avoid unintended data loss.
අනුපිටපත් දත්ත ලබා ගත හැකි වූ පසු, ඊළඟ පියවර වන්නේ අවශ්‍ය නොවන අනුපිටපත් මකා දැමීමයි. සාමාන්‍යයෙන්, අනුපිටපත් අතරින් එකම ලේඛනය තබා අනෙකුත් සියල්ල මකා දැමීම යන ක්‍රමය භාවිතා වේ. නමුත් MySQL හි අනුපිටපත් ස්වයංක්‍රීයව මකා දැමීමේදී, අනිසි දත්ත අහිමි වීම වැළැක්වීමට මකා දැමීමේ ඉලක්කය කාරුණිකව සීමා කළ යුතුය.

In this section, we explain common safe methods for deleting duplicate data and key precautions.
මෙම කොටසේ, අනුපිටපත් දත්ත මකා දැමීමට සාමාන්‍යයෙන් ආරක්ෂිත ක්‍රම සහ ප්‍රධාන අවධානම් පිළිබඳ විස්තර කරමු.

5-1. උපවිමසුම + DELETE සමඟ අනුපිටපත් මකා දැමීම

If you want to keep only the “oldest” or “newest” record and delete the others, a DELETE statement with a subquery can be useful.
ඔබට “පැරණිම” හෝ “නවතම” ලේඛනය පමණක් තබා අනෙකුත් මකා දැමීමට අවශ්‍ය නම්, උපවිමසුමක් සමඟ DELETE ප්‍රකාශයක් ප්‍රයෝජනවත් වේ.

Example: Keep the smallest (oldest) ID record and delete the others

උදාහරණය: කුඩාම (පැරණි) ID ලේඛනය තබා අනෙකුත් මකා දැමීම

DELETE FROM users
WHERE id NOT IN (
  SELECT MIN(id)
  FROM users
  GROUP BY email
);

This query keeps only the smallest id (the first registered record) for each email, and deletes all other rows that share the same email.
මෙම විමසුම සෑම ඊමේල් එකකටම කුඩාම id (පළමු ලියාපදිංචි ලේඛනය) පමණක් තබා, ඒ ඊමේල් එකට සම්බන්ධ අනෙකුත් සියලු පේළි මකා දැමීමට උපකාරී වේ.

5-2. MySQL-විශේෂ දෝෂය (Error 1093) වැළැක්වීමේ ක්‍රම

In MySQL, you may encounter Error 1093 when you try to DELETE from a table while also referencing the same table in a subquery. In that case, you can avoid the error by wrapping the subquery result as a derived table (temporary result set).
MySQL හි, ඔබට DELETE ප්‍රකාශයක් ක්‍රියාත්මක කරන අතරම ඒම වගුවක් උපවිමසුමකද පෙන්වන්නේ නම් Error 1093 දෝෂය මුණ ගැසෙයි. එවැනි අවස්ථාවක, උපවිමසුමේ ප්‍රතිඵලය අනුගත වගුවක් (තාවකාලික ප්‍රතිඵල කට්ටලයක්) ලෙස වටා ගැනීමෙන් මෙම දෝෂය වැළැක්විය හැක.

DELETE FROM users
WHERE id NOT IN (
  SELECT * FROM (
    SELECT MIN(id)
    FROM users
    GROUP BY email
  ) AS temp_ids
);

By wrapping the subquery with SELECT * FROM (...) AS alias, you can prevent the error and delete safely.
SELECT * FROM (...) AS alias ලෙස උපවිමසුම වටා ගැනීමෙන්, ඔබට දෝෂය වැළැක්වීමට සහ ආරක්ෂිතව මකා දැමීමට හැකියාව ලැබේ.

5-3. බහු-තීරු යතුරු සඳහා අනුපිටපත් මකා දැමීම

If you want to delete duplicates based on a combination of multiple columns, use GROUP BY with multiple columns and delete everything except the representative record.
බහු තීරු සංයෝගයක් මත අනුපිටපත් මකා දැමීමට අවශ්‍ය නම්, GROUP BY සමඟ බහු තීරු භාවිතා කර, නියෝජිත ලේඛනය හැර සියල්ල මකා දැමිය හැක.

Example: “first_name” සහ “birthday” අනුව අනුපිටපත් සඳහා, පළමු ලේඛනය හැර සියල්ල මකා දැමීම

උදාහරණය: “first_name” සහ “birthday” අනුව අනුපිටපත් සඳහා, පළමු ලේඛනය හැර සියල්ල මකා දැමීම

DELETE FROM users
WHERE id NOT IN (
  SELECT * FROM (
    SELECT MIN(id)
    FROM users
    GROUP BY first_name, birthday
  ) AS temp_ids
);

5-4. මකා දැමීම සඳහා ආරක්ෂක ක්‍රියාමාර්ග සහ හොඳම පුරුදු

Deleting duplicates is a high‑risk operation that can permanently remove data. Make sure to follow these best practices:
අනුපිටපත් මකා දැමීම දත්ත ස්ථිරව අහිමි කරවිය හැකි ඉතා අවදානම් ක්‍රියාවලියකි. පහත හොඳම පුරුදු අනුගමනය කිරීම අත්‍යවශ්‍යයි:

• උපස්ථාන ගන්න : මකා දැමීමට පෙර සම්පූර්ණ වගුව හෝ ඉලක්ක ලේඛන වල උපස්ථානයක් සුරකින්න.
• ගනුදෙනු (transactions) භාවිතා කරන්න : හැකි නම්, මෙය ගනුදෙනුවක් තුළ ගොඩනඟා, වැරදි සිදු වූ විට වහාම පසුපසට හැරවිය හැක.
• SELECT සමඟ ගණන තහවුරු කර පළමුව : “මකා දැමීමේ ඉලක්කය නිවැරදියිද?” යන ප්‍රශ්නය SELECT විමසුමක් මගින් පළමුව පරීක්ෂා කිරීමේ පුරුද්දක් ගොඩනඟන්න.
• ඉන්ඩෙක්ස් පරීක්ෂා කරන්න : අනුපිටපත් හඳුනා ගැනීමට භාවිතා වන තීරු වල ඉන්ඩෙක්ස් එකතු කිරීම කාර්ය සාධනය සහ නිරවද්‍යතාව දෙකම වැඩිදියුණු කරයි.

In MySQL, you can safely delete duplicate data by using subqueries and derived tables. Always proceed carefully, with sufficient testing and a solid backup strategy.
MySQL හි, උපවිමසුම් සහ අනුගත වගු භාවිතා කර අනුපිටපත් දත්ත ආරක්ෂිතව මකා දැමිය හැක. සැලකිලිමත් වන්න, ප්‍රමාණවත් පරීක්ෂණ සහ පූර්ණ උපස්ථාන සැලැස්වීම සමඟ.

6. කාර්ය සාධන සැලකිලි සහ ඉන්ඩෙක්ස් උපාය

When extracting or deleting duplicate data in MySQL, query execution time and server load become more problematic as the table grows. Especially in large‑scale systems or batch jobs, performance‑aware SQL design and index optimization are essential. In this section, we explain tips for improving performance and key points for index design in duplicate data processing.

6-1. EXISTS, IN, සහ JOIN අතර තේරීම

SQL constructs such as IN, EXISTS, and JOIN are commonly used for extracting duplicate data, but each has different characteristics and performance tendencies.

• IN – උපවිමසුම් ප්‍රතිඵල කට්ටලය කුඩා වන විට වේගවත්, නමුත් ප්‍රතිඵල කට්ටලය විශාල වන සමඟ කාර්ය සාධනය අඩුවේ.
• EXISTS – ගැලපෙන ලේඛනයක් සොයාගත් පසු සෙවීම නවත්වයි, එබැවින් විශාල වගු සඳහා හෝ ගැලපීම් අඩු වන විට ප්‍රයෝජනවත් වේ.
• JOIN – එකවර බොහෝ තොරතුරු ලබා ගැනීමට ප්‍රයෝජනවත්, නමුත් අවශ්‍ය නොවන දත්ත එක් කරනවා හෝ සුදුසු දර්ශක නොමැති නම් මන්දගාමී විය හැක.

කාර්ය සාධන උදාහරණ සැසඳීම

It is important to choose the optimal syntax based on your actual system and data volume.

ඔබගේ වත්මන් පද්ධතිය සහ දත්ත ප්‍රමාණය අනුව සුදුසු සින්ටැක්ස් තේරීම වැදගත් වේ.

6-2. දර්ශක නිර්මාණය වැදගත් වීමේ හේතු

For columns used in duplicate checks or deletion filters, always create indexes. Without indexes, full table scans can occur and performance can become extremely slow.

උදාහරණය: දර්ශකයක් නිර්මාණය කිරීම

CREATE INDEX idx_email ON users(email);

If you detect duplicates across multiple columns, a composite index is also effective.

ඔබ බහු තීරුවල අනුපිටපත් හඳුනාගත් නම්, සංයුක්ත දර්ශකයක්ද ප්‍රයෝජනවත් වේ.

CREATE INDEX idx_name_birthday ON users(first_name, birthday);

Index design can dramatically change read performance and search efficiency.
Note: Adding too many indexes can slow down writes and increase storage usage, so balance is important.

දර්ශක නිර්මාණය කියවීමේ කාර්ය සාධනය සහ සෙවීමේ කාර්යක්ෂමතාවය දැඩි ලෙස වෙනස් කරයි.
සටහන: දර්ශක බොහෝමයක් එකතු කිරීම ලිවීමේ වේගය අඩු කරයි සහ ගබඩා භාවිතය වැඩි කරයි, එබැවින් සමතුලිතතාවය වැදගත් වේ.

6-3. විශාල දත්ත කට්ටල සඳහා බැච් සැකසීම

• දත්ත කට්ටලය දස දහස් ගණනකින් මිලියන ගණනක් පමණ පේළි ගණනක් වන විට, සියල්ල එකවර සැකසීම වෙනුවට කුඩා බැච් වලින් සැකසීම ආරක්ෂිත වේ.
• මකා දැමීම සහ යාවත්කාලීන කිරීම සඳහා, එක් ක්‍රියාත්මක කිරීමකට සැකසෙන පේළි ගණන සීමා කරන්න (උදා: LIMIT 1000) සහ ලොක් තරඟය සහ කාර්ය සාධන අඩු වීම අඩු කිරීම සඳහා බහු වරක් ක්‍රියාත්මක කරන්න. DELETE FROM users WHERE id IN ( -- උපවිමසුමක් මගින් ලබාගත් පළමු 1000 අනුපිටපත් ලේඛන ID ) LIMIT 1000;

6-4. ක්‍රියාත්මක සැලසුම් (EXPLAIN) භාවිතය

Use EXPLAIN to analyze how a query is executed. This helps you check whether indexes are being used effectively, and whether a full scan (ALL) is occurring.

EXPLAIN SELECT * FROM users WHERE email IN (...);

By keeping performance and index strategy in mind, you can handle duplicate processing safely and efficiently even for large datasets.

කාර්ය සාධනය සහ දර්ශකยุත්‍රණය මතක තබා, විශාල දත්ත කට්ටල සඳහාද අනුපිටපත් සැකසීම ආරක්ෂිතව සහ කාර්යක්ෂමව කළ හැක.

7. උසස් භාවිත නඩු: සංකීර්ණ අවස්ථා සැකසීම

In real‑world environments, duplicate detection and deletion are often more complex than simple matching. You may need to add additional conditions, execute operations safely in stages, or meet stricter operational requirements. In this section, we introduce advanced practical techniques for handling duplicate data safely and flexibly.

7-1. කොන්දේසිමය අනුපිටපත් මකා දැමීම

If you want to delete only duplicates that meet specific conditions, use the WHERE clause strategically.

උදාහරණය: එකම ඊමේල් සහ status = 'withdrawn' ඇති අනුපිටපත් ලේඛන පමණක් මකා දැමීම

DELETE FROM users
WHERE id NOT IN (
  SELECT * FROM (
    SELECT MIN(id)
    FROM users
    WHERE status = 'withdrawn'
    GROUP BY email
  ) AS temp_ids
)
AND status = 'withdrawn';

By adding conditions to WHERE and GROUP BY, you can precisely control which records to keep and which to remove.

WHERE සහ GROUP BY වෙත කොන්දේසි එක් කිරීමෙන්, ඔබට තබා ගැනීමට සහ මකා දැමීමට අවශ්‍ය ලේඛන නිරවද්‍යව පාලනය කළ හැක.

7-2. නිර්දේශිතය: බැච් සැකසීම සහ වෙන් කර ක්‍රියාත්මක කිරීම

If the dataset is very large or you want to avoid lock contention and performance degradation, use batch processing.

batch processing භාවිතා කරන්න.

• සියලුම මකාදැමීමේ ඉලක්ක එකවර සකස් නොකරන්න—විභජිත ක්‍රියාත්මක කිරීම සඳහා LIMIT භාවිතා කරන්න
• අනපේක්ෂිත දෝෂ සිදුවන විට ගනුදෙනු පාලනය භාවිතා කර රෝල්බැක් (rollback) කරන්න
• පිටපත් (backup) සහ ලොග් කිරීමෙන් අවදානම කළමනාකරණය කරන්න DELETE FROM users WHERE id IN ( SELECT id FROM ( -- Extract duplicate record IDs filtered by conditions ) AS temp_ids ) LIMIT 500;

මෙම ක්‍රමය පද්ධතියේ භාරය ගණනාවෙන් අඩු කරයි.

7-3. සංකීර්ණ නකල් නිර්වචන හසුරවීම

විවිධ ව්‍යාපාරික පරිසරයන්හි “නකල්” යන වචනයේ අර්ථය වෙනස් වේ. ඔබට උපවිමසුම්, CASE ප්‍රකාශන, සහ එකතු කිරීමේ ක්‍රියා එකතු කර ගත හැක, එය සවිස්තරාත්මකව හසුරවීමට.

උදාහරණය: product_id, order_date, සහ price සියල්ල එකසේ වන විට පමණක් නකල් ලෙස සැලකීම

SELECT product_id, order_date, price, COUNT(*)
FROM orders
GROUP BY product_id, order_date, price
HAVING COUNT(*) > 1;

“නකල් අතරින් නවතම රෙකෝඩ් එක පමණක් තබා ගැනීම” වැනි උසස් අවශ්‍යතා සඳහා, ඔබට උපවිමසුම් හෝ ROW_NUMBER() (MySQL 8.0 සහ පසුගිය සංස්කරණ වල ලබා ගත හැක) භාවිතා කළ හැක.

7-4. ගනුදෙනු සහ පිටපත් (Backups) සඳහා හොඳම පුරුදු

• DELETE හෝ UPDATE ක්‍රියාකාරකම් සෑම විටම ගනුදෙනු තුළ වැසිය යුතුය එවිට ගැටළු ඇති වූ විට ROLLBACK මඟින් දත්ත ප්‍රතිස්ථාපනය කළ හැක.
• වැදගත් වගු හෝ විශාල දත්ත කට්ටල සමඟ වැඩ කරන විට, සෑම විටම පෙර පිටපතක් (backup) සකස් කරන්න .

මෙම උසස් තාක්ෂණයන් අත්හදා බැලීමෙන්, ඔබට නකල් දත්ත සැකසීම ආරක්ෂිතව සහ සවිස්තරාත්මකව ඕනෑම පරිසරයක හසුරවිය හැක.

8. සාරාංශය

මෙම ලිපියේ, MySQL හි නකල් දත්ත ලබා ගැනීම සහ මකාදැමීම පිළිබඳ මූලික කරුණු සිට උසස් යෙදුම් දක්වා පද්ධතිමය ලෙස පැහැදිලි කර ඇත. දැන් ප්‍රධාන කරුණු සමාලෝචනය කරමු.

8-1. ප්‍රධාන සාරාංශ

• නකල් දත්ත හඳුනා ගැනීම ඔබට නකල් එක තනි තීරුවක පමණක් නොව, බහු තීරුවලද හඳුනා ගත හැක. GROUP BY සහ HAVING COUNT(*) > 1 එකතුව නකල් හඳුනා ගැනීමේ මූලික රටාවයි.
• සියලු නකල් රෙකෝඩ් ලබා ගැනීම උපවිමසුම් සහ EXISTS කොටස භාවිතා කර, නකල් යතුරු අගයන්ට අදාළ සියලු රෙකෝඩ් ලබා ගත හැක.
• නකල් රෙකෝඩ් මකාදැමීම MIN(id) හෝ MAX(id) භාවිතා කර නියෝජිත පේළි තබා, උපවිමසුම් සමඟ DELETE ප්‍රකාශන එකතු කිරීමෙන් අවශ්‍ය නොවන නකල් ආරක්ෂිතව ඉවත් කළ හැක. MySQL දෝෂ 1093 වැළැක්වීමද වැදගත්.
• කාර්ය සාධනය සහ ඉන්ඩෙක්සිං විශාල දත්ත කට්ටල හෝ සංකීර්ණ කොන්දේසි සඳහා, නිසි ඉන්ඩෙක්සිං, කණ්ඩායම් සැකසීම, සහ EXPLAIN භාවිතා කර ක්‍රියාත්මක සැලැස්ම පරීක්ෂා කිරීම අත්‍යවශ්‍ය වේ.
• ප්‍රායෝගික තාක්ෂණ කොන්දේසි මත මකාදැමීම, විභජිත ක්‍රියාත්මක කිරීම, ගනුදෙනු කළමනාකරණය, සහ පිටපත් (backups) යනු නිෂ්පාදන පරිසරයේ වැරදි වැළැක්වීමට ප්‍රධාන පුරුදු වේ.

8-2. භාවිත නඩුව අනුව ඉක්මන් යොමු කිරීම

8-3. අනාගත නකල් ගැටළු වැළැක්වීම

ඇතුළත් කිරීමේදී නකල් වැළැක්වීමද සමාන ලෙස වැදගත් වේ.

• වගුව නිර්මාණයේ UNIQUE සීමා (constraints) භාවිතා කිරීම ගැන සලකා බලන්න.
• නිතර දත්ත පිරිසිදු කිරීම සහ පරීක්ෂණය මඟින් මෙහෙයුම් ගැටළු මුලින්ම හඳුනා ගැනීමට උපකාරී වේ.

MySQL හි නකල් දත්ත ලබා ගැනීම සහ මකාදැමීම සඳහා මූලික SQL සිට උසස් තාක්ෂණ දක්වා දැනුම අවශ්‍ය වේ. මෙම මාර්ගෝපදේශය ඔබේ දත්ත ගබඩා නඩත්තු සහ පද්ධති මෙහෙයුම් සඳහා උපකාරී වේ කියා අපි බලාපොරොත්තු වෙමු.
ඔබට විශේෂ අවස්ථා හෝ අමතර ප්‍රශ්න තිබේ නම්, FAQ පරීක්ෂා කිරීම හෝ දත්ත ගබඩා විශේෂඥයෙකු සමඟ උපදෙස් ගැනීමට සිතන්න.

9. FAQ: MySQL හි නකල් දත්ත ලබා ගැනීම සහ මකාදැමීම පිළිබඳ නිතර අසන ප්‍රශ්න

Q1. GROUP BY + HAVING භාවිතා කිරීම DISTINCT වෙනුවට කෙළින්ම ඇයි?

DISTINCT ප්‍රතිඵල කට්ටලයේ නකල් ඉවත් කරයි, නමුත් ඒ අගය කී වරක් පෙනේදැයි ඔබට කියා නොදෙයි. GROUP BY සහ HAVING COUNT(*) > 1 එකතු කිරීමෙන්, කී වරක් පෙනෙන අගයන් සහ නකල් ගණන තීරණය කළ හැක.

Q2. IN හෝ EXISTS භාවිතා කළ යුතුද?

කුඩා දත්ත කට්ටල සඳහා, වෙනස අඩුය. විශාල වගු හෝ ඉන්ඩෙක්සිං ප්‍රයෝජනවත් වන විට, EXISTS සාමාන්‍යයෙන් වඩා හොඳ ක්‍රියාකාරිත්වයක් ලබා දෙයි. ඔබේ පරිසරයේ දෙකම පරීක්ෂා කර, EXPLAIN භාවිතා කර ක්‍රියාත්මක සැලැස්ම පරීක්ෂා කරන්න.

Q3. බහු තීරුවල නකල් කෙසේ හඳුනා ගත හැකිද?

Specify multiple columns in GROUP BY and use HAVING COUNT(*) > 1 to detect combinations where all specified columns match. Example: GROUP BY first_name, birthday

Q4. DELETE ක්‍රියාත්මක කිරීමේදී Error 1093 ලැබේ. මොකද කළ යුතුද?

MySQL DELETE ප්‍රකාශයක් තුළ උපවිමසුමකදී එකම වගුවට යොමු කරන විට Error 1093 දෝෂය දක්වයි. මෙම දෝෂය වැළැක්වීමට උපවිමසුම් ප්‍රතිඵලය SELECT * FROM (...) AS alias ලෙස උත්පන්න වගුවක් (derived table) තුළ ගැලවීම කරන්න.

Q5. අනුපිළිවෙල දත්ත ආරක්ෂිතව මකා දැමීමට මොකද කළ හැක්කේ?

මකා දැමීමට පෙර සැමවිටම බැකප් එකක් සාදන්න, SELECT ප්‍රකාශයක් භාවිතා කර ඉලක්කයන් තහවුරු කරන්න, සහ හැකි තැන්වල ගනුදෙනු (transactions) භාවිතා කරන්න. විශාල දත්ත කට්ටල සඳහා කණ්ඩායම් (batch) මකා දැමීමත් ආරක්ෂිත විය හැක.

Q6. විශාල දත්ත ප්‍රමාණ සමඟ විමසුම් මන්දගාමී වන්නේ නම් මොකද කළ යුතුද?

අනුපිළිවෙල හඳුනා ගැනීමට භාවිතා කරන තීරුවල ඉන්ඩෙක්ස් (indexes) සාදන්න. LIMIT සමඟ කණ්ඩායම් (batch) සැකසීම භාවිතා කර, EXPLAIN භාවිතා කර ක්‍රියාත්මක සැලසුම් (execution plans) පරීක්ෂා කර, අනිවාර්ය නොවන සම්පූර්ණ වගු පරික්ෂණ (full table scans) වලින් වැළැක්වන්න.

Q7. අනුපිළිවෙල ඇතුළත් කිරීම් මූලිකව වැළැක්වීමට මොකද කළ හැක්කේ?

UNIQUE සීමා (constraints) හෝ අද්විතීය යතුරු (unique keys) වගුව සැලසුම් කිරීමේදී නිර්වචනය කර, අනුපිළිවෙල අගයන් ඇතුළත් වීම වැළැක්වන්න. එසේම, නිකුත් කිරීමෙන් පසු නිතර අනුපිළිවෙල පරීක්ෂා කිරීම සහ දත්ත පිරිසිදු කිරීම (data cleansing) සිදු කරන්න.

Q8. ඒම ක්‍රම MariaDB හෝ වෙනත් RDBMS වලද භාවිතා කළ හැකිද?

GROUP BY, HAVING, සහ උපවිමසුම් (subqueries) වැනි මූලික SQL සංරචනා MariaDB සහ PostgreSQL වලද සහාය දක්වයි. එNevertheless, DELETE උපවිමසුම් සීමා සහ කාර්ය සාධන ලක්ෂණ (performance characteristics) නිෂ්පාදනය අනුව වෙනස් විය හැකි බැවින්, සැමවිටම පෙර පරීක්ෂා කරන්න.