MySQL FIND_IN_SET() පැහැදිලි කිරීම: කොමා-වෙන් කරන ලද අගයන් ආරක්ෂිතව සොයන්න (උදාහරණ සමඟ)

1. හැඳින්වීම: FIND_IN_SET අවශ්‍ය වන සාමාන්‍ය තත්ත්ව

MySQL හි දත්ත සමඟ වැඩ කිරීමේදී, ඔබට “එක කොලමකින් වෙන් වී ඇති කොමාවලින් වෙන් කර ඇති බහු වටිකි” ගබඩා කර ඇති අවස්ථාවන්ට මුහුණ දීමට සිදුවිය හැක. උදාහරණයක් ලෙස, පරිශීලකයා විසින් තෝරාගත් ටැග්, කාණ්ඩ තොරතුරු හෝ වින්‍යාසන ගැනුම්කරුවන් එක එක ස්ත්‍රිං එකක් ලෙස php,python,sql මෙන් ගබඩා කර තිබිය හැක.

මෙවැනි ව්‍යුහයක් දත්ත සමාකාරණයේ දෘෂ්ටිකෝණයකින් නිර්දේශ නොකෙරේ. කෙසේ වෙතත්, පවතින පද්ධති සැලසුම් මත රඳා පවතින අවස්ථාවන්හිදී හෝ නම්‍යශීලී දත්ත ආදානයට ප්‍රමුඛත්වය දෙන විට, ඔබට මෙම ආකෘතිය භාවිතා කිරීමට සැබෑවටම සිදුවිය හැක.

ටැග් සෙවීම අපහසු වන විට ජීවිත බේරගන්නාවක්

උදාහරණයක් ලෙස, ඔබට පරිශීලකයෙකුට “python” ටැග් තිබේදැයි පරීක්ෂා කිරීමට අවශ්‍ය යැයි උපකල්පනය කරන්න. සාමාන්‍ය = ක්‍රියාකාරකය හෝ LIKE ක්‍රියාකාරකය භාවිතයෙන්, අර්ධ වගකීම් සහ ආසන්න අකුරු නිසා නිරවද්‍යතාවයේ සීමාවන් ඇත, එය වැරදි ප්‍රතිඵලවලට තුඩු දිය හැක.

එහිදී FIND_IN_SET() ශක්තිය ලබා දෙනු ලැබේ.

FIND_IN_SET() යනු කොමාවලින් වෙන් කර ඇති ස්ත්‍රිං එකක් තුළ විශේෂිත ස්ත්‍රිං එකක පිහිටිය (අනුපිට) තීරණය කරන MySQL ශක්තියකි. සොයාගත් විට, එය සුඛුම්‍ය (1 සිට ආරම්භ වන) ආපසු දෙයි. සොයාගැනීමක් නොමැති නම්, එය 0 ආපසු දෙයි. මෙම හැසිරීම සමඟ, ඔබට ටැග්, කාණ්ඩ හෝ සැකසුම් ඇතුළත් බව නිවැරදිව සහ නම්‍යශීලීව තීරණය කළ හැක.

සාමාන්‍ය භාවිතා අවස්ථා

FIND_IN_SET බබළන සාමාන්‍ය තත්ත්වවලට ඇතුළත් වන්නේ:

• එක ක්ෂේත්‍රයක ගබඩා කර ඇති කොමාවලින් වෙන් කර ඇති “ටැග්” හෝ “කාණ්ඩ” වලින් විශේෂිත වටිකාවක් නිදහස් කිරීමට ඔබට අවශ්‍ය වන විට
• පරිපාලන තිරයක ඇතුළත් කර ඇති CSV-ආකාරයේ වටිකි සෙවුම් තත්ත්ව වශයෙන් භාවිතා කිරීමට ඔබට අවශ්‍ය වන විට
• WordPress වැනි CMS හි මෙටා තොරතුරුවලට එරෙහි නම්‍යශීලී පෙරාදිම්කරණයට ඔබට අවශ්‍ය වන විට
• ස්කීම් වෙනස් නොකර එක කොලමක බහු-තෝරාගැනීමේ වටිකි ගබඩා කර ඇති පවතින වගුවක් සැකසීමට ඔබට අවශ්‍ය වන විට

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

2. FIND_IN_SET ශක්තිය කුමක්ද? (මූලික ව්‍යාකරණය සහ ආපසු වටිකාව)

MySQL හි FIND_IN_SET() ශක්තිය යනු කොමාවලින් වෙන් කර ඇති ස්ත්‍රිං එකක් තුළ විශේෂිත වටිකාවක පිහිටිය පරීක්ෂා කිරීමට භාවිතා වන ශක්තියකි. එය විශේෂයෙන්ම එක ක්ෂේත්‍රයක බහු වටිකි එකතුවෙන් ගබඩා කර ඇති විට ගුණදායකය.

මෙම ශක්තිය MySQL වෙත විශේෂිත වන අතර අනෙකුත් දත්ත සමාධානවල (PostgreSQL හෝ SQLite මෙන්) අත්වාරයෙන් ලබා නොගත හැකි බැවින්, එය MySQL-විශේෂිත විශේෂාංගයක් ලෙස සැලකිය හැක.

මූලික ව්‍යාකරණය

FIND_IN_SET(search_value, comma_separated_string)

• search_value : ඔබ සොයන්නට අවශ්‍ය ස්ත්‍රිං එක
• comma_separated_string : සෙවීමට අවශ්‍ය කොමාවලින් වෙන් කර ඇති ලැයිස්තුව

උදාහරණය

පහත SQL එක සලකන්න:

SELECT FIND_IN_SET('python', 'php,python,sql');

මෙම අවස්ථාවේදී, 'python' යනු දෙවන අයිතමය වන බැවින්, ආපසු වටිකාව 2 ය.

වෙනත් අතකින්, නිර්දිෂ්ට වටිකාව ලැයිස්තුවේ නොමැති නම්, 0 ආපසු දෙයි:

SELECT FIND_IN_SET('ruby', 'php,python,sql');
-- Result: 0

එසේම, ඕනෑම තර්කයක් NULL නම්, ආපසු වටිකාව ද NULL ය.

SELECT FIND_IN_SET(NULL, 'php,python,sql');
-- Result: NULL

ආපසු වටිකාවේ නීති

ආපසු වටිකාව ඵලදායී ලෙස භාවිතා කිරීමෙන්, ඔබට FIND_IN_SET භාවිතා කළ හැකි වන්නේ සෙවීමට පමණක් නොව, “වටිකාවක් පෙනෙන අනුපිට පරීක්ෂා කිරීම” වැනි අවස්ථා සඳහා ද.

වැදගත් සටහන: 0 යනු “සොයාගැනීමක් නැත” යන්නයි

ආපසු වටිකාව 0 වන විට, එය “ලැයිස්තුවේ සොයාගැනීමක් නැත” යන්න පෙන්වයි. MySQL හි, 0 FALSE ලෙස සැලකෙන බැවින්, WHERE කොටසක එය සෘජුව භාවිතා කිරීමේදී හැසිරීම නොදන්නා නම් බෙදීමක් ඇති කළ හැක.

ඊළඟ කොටසේදී, අපි සැබෑ වගු දත්තවලට එරෙහිව FIND_IN_SET භාවිතා කිරීමේ මූලික ප්‍රශ්න උදාහරණ පෙන්වන්නෙමු.

3. ප්‍රායෝගික උදාහරණය 1: මූලික භාවිතය (සරල SELECT ප්‍රශ්නයක්)

FIND_IN_SET() ශක්තිය එහි නාමය පෙන්වන පරිදි—“සෙට් එකක් තුළ සොයන්න” යන අර්ථයයි. නමුත් එය සැබෑ වගු දත්ත වලට යෙදෙන විට ඔබ එය කෙසේ ලියන්න යුතුද?
මෙහි, අපි මූලික SELECT ප්‍රකාශයක් භාවිතා කරමින් සරලතම භාවිතය පියවරෙන් පියවර ගමන් කරමු.

සාම්පල වගුවක් සකසන්න

පහත වගුව සලකන්න:

වගුවේ නාමය: user_tags

tags තීරුව පරිශීලකයන් විසින් ලියාපදිංචි කරන කුසලතා ටැග්‌들을 කොමා-වෙන් කරන ලද 문자열යක් ලෙස ගබඩා කරයි.

උදාහරණය: “python” අඩංගු පරිශීලකයන් සොයන්න

“python” ටැග් එකක් ඇති පරිශීලකයන් පමණක් ලබා ගැනීමට, පහත SQL ලියන්න:

SELECT * FROM user_tags
WHERE FIND_IN_SET('python', tags);

ප්‍රතිඵලය:

පෙන්වා ඇති පරිදි, tags තීරුවේ “python” අඩංගු වන ලේඛන පමණක් ආපසු ලබා දේ.

නිරවද්‍ය 문자열 ගැළපීම මූලිකය

FIND_IN_SET() නිරවද්‍ය 문자열 සමානතාව මත පදනම්ව ගැළපේ. එයින් අදහස් වන්නේ “py” හෝ “pyth” වැනි අර්ධ 문자열 ගැළපීම නොවන බවයි. ඔබට අර්ධ ගැළපීම අවශ්‍ය නම් LIKE භාවිතා කළ හැක, නමුත් LIKE '%python%' වැනි ලියීම අනවශ්‍ය අන්තර්ගතයන් සමඟ වැරදිව ගැළපී, කොමා-වෙන් කරන ලද ලැයිස්තු සඳහා අවදානම් වේ. එබැවින්, FIND_IN_SET සාමාන්‍යයෙන් කොමා-වෙන් කරන ලද ලැයිස්තු සඳහා වඩා සුදුසුය.

උදාහරණය: SQL හි විචල්‍යයක් සමඟ සෙවීම

ඔබට සෙවීමේ අගය ගතිකව වෙනස් කිරීමට අවශ්‍ය නම්, විචල්‍යයක් භාවිතා කළ හැක:

SET @skill = 'python';

SELECT * FROM user_tags
WHERE FIND_IN_SET(@skill, tags);

මෙම රටාව යෙදුම් හෝ ගබඩා කළ ක්‍රියාවලීන් සමඟ ඒකාබද්ධ කිරීමේදීද ප්‍රයෝජනවත් වේ.

4. ප්‍රායෝගික උදාහරණ 2: ගතික සෙවීම් (විචල්‍ය සහ පෝරම ඒකාබද්ධ කිරීම) සඳහා සහය

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

විචල්‍ය සහ පසුපස ඒකාබද්ධ කිරීම සලකා බලමින් ප්‍රායෝගික භාවිත රටා මෙහි ඇත.

SQL විචල්‍ය භාවිතා කර ගතික සෙවීම

ඔබ MySQL සැසිය විචල්‍ය (@variable_name) භාවිතා කරනවා නම්, සෙවීමේ අගය ඉහළින් 정의 කර එය බහු ප්‍රශ්නවලදී නැවත භාවිතා කළ හැක:

-- Store the tag you want to search for in a variable
SET @target_tag = 'python';

-- Dynamic search with FIND_IN_SET
SELECT * FROM user_tags
WHERE FIND_IN_SET(@target_tag, tags);

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

යෙදුම් ඒකාබද්ධ කිරීම: PHP උදාහරණය

උදාහරණයක් ලෙස, වෙබ් පෝරම ආදානය මත පදනම්ව SQL නිකුත් කිරීමට PHP භාවිතා කරනවා නම්, ඔබට මෙවැනි කේතයක් ලියන්න පුළුවන්:

<?php
$tag = $_GET['tag']; // Example: form input "python"

// Build SQL (a prepared statement is recommended)
$sql = "SELECT * FROM user_tags WHERE FIND_IN_SET(?, tags)";

$stmt = $pdo->prepare($sql);
$stmt->execute([$tag]);
$results = $stmt->fetchAll();
?>

පූර්ව-තැන්පත් ප්‍රකාශයක් සමඟ ඒකාබද්ධ කිරීමෙන්, SQL ඉන්ජෙක්ශන් වලට පටුන ආරක්ෂාව ලබා දේ.

WordPress භාවිතය: අභිරුචි ක්ෂේත්‍රවල ටැග් සෙවීම

WordPress හි, meta_query භාවිතා කර අභිරුචි ක්ෂේත්‍ර සෙවිය හැක, නමුත් FIND_IN_SET එකතු කිරීමට අවශ්‍ය නම්, සාමාන්‍යයෙන් සෘජු SQL භාවිතා කළ යුතුය, මෙසේ:

උදාහරණය: අභිරුචි ක්ෂේත්‍ර _user_tags "php,python,sql" ලෙස ගබඩා කරන විට

global $wpdb;
$tag = 'python';

$sql = $wpdb->prepare(
  "SELECT * FROM {$wpdb->prefix}postmeta WHERE meta_key = %s AND FIND_IN_SET(%s, meta_value)",
  '_user_tags', $tag
);
$results = $wpdb->get_results($sql);

මෙම ක්‍රමය WordPress හි සාමාන්‍ය විශේෂතා සපයන නොහැකි ලච්චිත සෙවීම් සක්‍රිය කරයි.

වැදගත්: හිස් ඉඩ සහ පූර්ණ-පළල කොමා ගැන සැලකිල්ලෙන් සිටින්න

FIND_IN_SET භාවිතා කරන විට, කොමා-වෙන් කරන ලද 문자열යේ අතිරේක හිස් ඉඩ හෝ පූර්ණ-පළල අක්ෂරයන් ගැළපීම වැලැක්විය හැක.
එබැවින්, පහත පරිදි පෙර-සැකසීම කිරීම සුදුසුය:

• TRIM() ක්‍රියාවලිය භාවිතා කර හිස් ඉඩ ඉවත් කිරීම
• කොමා ආකෘති සාමාන්‍ය කිරීම (පූර්ණ-පළල → අර්ධ-පළල)
• යෙදුම් පැත්තේ ආදාන වල සත්‍යතා පරීක්ෂා කිරීම

5. FIND_IN_SET සමඟ උසස් තාක්ෂණ (GROUP_CONCAT, උපප්‍රශ්න, JOIN)

FIND_IN_SET ශ්‍රිතය සරල තනි-ක්ෂේත්‍ර සෙවීම්ට වඩා වැඩි දේ කළ හැකිය. එය වෙනත් SQL ශ්‍රිත සමඟ සහ උප-ප්‍රශ්න සමඟ ඒකාබද්ධ කිරීමෙන්, ඔබට වඩා නම්‍යශීලී සහ සංකීර්ණ සෙවුම් තර්කයක් ගොඩනඟා ගත හැකිය. මෙම කොටස තුනක සුලබ උසස් රටා හඳුන්වා දෙයි.

GROUP_CONCAT සමඟ ඒකාබද්ධ කිරීම

පළමුව, GROUP_CONCAT() සමඟ ඒකාබද්ධ කිරීම, එය බහු පේළි එක කොමා-වෙන් කළ විශේෂාංගයක් ලෙස සැලකිය හැකිය. මෙය ඔබට එක් පිඨාපිටියකින් ටැග් ලැයිස්තුවක් ගොඩනඟා ගැනීමට සහ එය තවත් පිඨාපිටියක සෙවීමේ කොන්දේසියක් ලෙස භාවිතා කිරීමට උපකාරී වේ.

උදාහරණය: user_tags හි tags කොලම්හි වලංගු සංඛ්‍යා master_tags වලින් ටැග් ලැයිස්තුවක් සමඟ සංසන්දනය කිරීම

SELECT *
FROM user_tags
WHERE FIND_IN_SET('python', (
  SELECT GROUP_CONCAT(tag_name)
  FROM master_tags
));

මෙම ප්‍රශ්නයේදී, master_tags හි ටැග් ලැයිස්තුව එක කොමා-වෙන් කළ විශේෂාංගයක් බවට පරිවර්තනය වන අතර, FIND_IN_SET() එයට ගැලපෙන ගැලපීම් පරීක්ෂා කරයි.

GROUP_CONCAT මගින් ජනනය වන විශේෂාංගයේ දිග සීමාවක් ඇත (පෙරනිමි 1024 අක්ෂර). ඔබට බොහෝ වලංගු තිබේ නම්, group_concat_max_len සැකසුම පරීක්ෂා කරන්න.

උප-ප්‍රශ්නයක් භාවිතයෙන් ගතිකව වලංගු සංඛ්‍යාවක් ලබා ගැනීම

ඊළඟට, උප-ප්‍රශ්නයක් භාවිතයෙන් සෙවුම් ඉලක්ක වලංගු සංඛ්‍යාව ගතිකව ලබා ගන්නා රටාවක් FIND_IN_SET ට ලබා දෙයි.

උදාහරණය: කළමනාකරණ පිඨාපිටියකින් සෙවුම් කොන්දේසියක් ලබා ගැනීම සහ දත්ත පෙරදර්ශනය කිරීම

SELECT *
FROM user_tags
WHERE FIND_IN_SET(
  'python',
  (SELECT setting_value FROM search_conditions WHERE id = 1)
);

මෙහිදී, සෙවුම් කොන්දේසිය කළමනාකරණ පිඨාපිටියක ගබඩා වී ඇති අතර, පද්ධති සැකසුම් යාවත්කාලීන කිරීමෙන් පමණක් සෙවුම් හැසිරීම වෙනස් කළ හැකිය.
මෙය සකස් කළ හැකි පරිපාලක තිර සහ ඩෑෂ්බෝඩ්-ආකාර යෙදුම් සඳහා පහසු විය හැකිය.

JOIN සමඟ සංසන්දනය: නිර්මාණශීලී සැකැස්මක JOIN වඩා හොඳින් ක්‍රියා කරයි

FIND_IN_SET පහසුය, නමුත් ඔබගේ දත්ත සමුදායන සැලසුම නිවැරදිව නිර්මාණශීලී නම්, JOIN සමඟ සෙවීම වඩා කාර්යක්ෂම සහ ආරක්ෂිත වේ.

උදාහරණයක් ලෙස, සම්බන්ධතාවයක් බහු-බහු භාවිතා කරමින් සම්බන්ධක පිඨාපිටියක් භාවිතා කරන විට, ඔබට JOIN සමඟ සෙවීම පිරිසිදුව ක්‍රියාත්මක කළ හැකිය:

උදාහරණ ව්‍යුහය:

• users පිඨාපිටිය
• tags පිඨාපිටිය
• user_tag_relation පිඨාපිටිය (user_id සහ tag_id ගබඩා කරන සම්බන්ධක පිඨාපිටිය)

  SELECT users.*
  FROM users
  JOIN user_tag_relation ON users.id = user_tag_relation.user_id
  JOIN tags ON user_tag_relation.tag_id = tags.id
  WHERE tags.name = 'python';
  

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

ඔබ කුමන ප්‍රවේශය තෝරා ගත යුතුද?

6. FIND_IN_SET හි අභියෝග සහ සැලකිලිමත් කළ යුතු දේ (කාර්ය සාධනය සහ සැලසුම)

FIND_IN_SET කොමා-වෙන් කළ විශේෂාංගවලට එරෙහි නම්‍යශීලී සෙවීම් සක්‍රිය කරන පහසු ශ්‍රිතයක් වන නමුත්, එය අනවධානයෙන් භාවිතා නොකළ යුතුයි.
මෙම කොටසේදී, කාර්ය සාධනය සහ දත්ත සමුදායන සැලසුමේ අවදානම් සම්බන්ධ සුලබ යථාර්ථ ගැටලු පැහැදිලි කරමු.

සුචිකරණ භාවිතා කළ නොහැකි නිසා දුර්වල කාර්ය සාධනය

FIND_IN_SET හි විශාලතම දුර්වලතාව වන්නේ එය ඉලක්ක කොලම්හි සුචිකරණය කිරීම වළක්වයි යි.

උදාහරණයක් ලෙස, පහත ප්‍රශ්නය සලකන්න:

SELECT * FROM user_tags
WHERE FIND_IN_SET('python', tags);

tags කොලම් සුචිකරණය වී ඇත්ද යනුවෙන් පවා, FIND_IN_SET භාවිතය සම්පූර්ණ පිඨාපිටි පරීක්ෂණයක් බල කරයි, එනම් MySQL එක් එක් පේළිය කියවා විශේෂාංගය විශ්ලේෂණය කළ යුතුයි.

අනුප්‍රාප්තියක් ලෙස, විශාල දත්ත සමුදායන් සඳහා (හැමදාහක් සිට දහහක් හැමදාහක් පේළි දක්වා සහ ඊට ඔබ්බෙන්), සෙවීමේ වේගය තීව්‍රව පහත වැටිය හැකිය.

අනුරූප ප්‍රතිචාර:

• සුදුසු විට සම්බන්ධක පිඨාපිටිය භාවිතයෙන් නිර්මාණශීලීකරණය සලකන්න
• FIND_IN_SET භාවිතා කළ යුතු නම්, පළමුව වේදිකාවන් සීමා කරන්න ( LIMIT භාවිතා කරන්න හෝ වෙනත් WHERE කොන්දේසි සමඟ ඒකාබද්ධ කරන්න)

එය නිර්මාණශීලී නොවන ව්‍යුහයක් දිරිමත් කරයි

එක කොලමක කොමා-වෙන් කළ වලංගු ගබඩා කිරීම දත්ත සමුදායන නිර්මාණශීලීතා මූලධර්ම උල්ලංඝනය කරයි.

උදාහරණයක් ලෙස, "php,python,sql" වැනි තන්තුව පහසු ලෙස පෙනේ, නමුත් එය පහත සඳහන් ගැටළු ඇති කරයි:

• එක් එක් අගය සඳහා අසීරු එකතු කිරීම සහ සංඛ්‍යාත්මක සැකසීම
• අගයක් එකක් පමණක් යාවත්කාලීන කිරීම හෝ මැකීම අමාරුය
• අනුපිළිවෙළ සහ අක්ෂර දෝෂ (උදාහරණයක් ලෙස, “Python” vs “python”) පහසුවෙන් සිදුවේ

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

කොමා නොවන අක්ෂර හෝ හිස් ඉඩ (whitespace) නිසා සෙවීමේ අසාර්ථකතා

FIND_IN_SET ඉතා සංවේදී වේ. දත්තය පහත සඳහන් ගැටළු ඇතුළත් නම්, ගැලපීම අසාර්ථක වේ:

• අගයන් අවට හිස් ඉඩ (අවකාශ, ටැබ්, නව පේළි)
• පූර්ණ-පළල කොමා (、)
• අනපේක්ෂිත උද්ධෘත ලකුණු (ද්විත්ව උද්ධෘත හෝ එකක උද්ධෘත)

උදාහරණය:

FIND_IN_SET('python', 'php, python ,sql')
-- => No match (because it becomes " python " with spaces)

ප්‍රතිකාර:

• ඇතුළත් කිරීමේදී TRIM() භාවිතයෙන් හිස් ඉඩ ඉවත් කරන්න
• REPLACE(tags, ' ', '') සමඟ ආදානය පෙර සැකසීම
• ඉදිරිපස (frontend) හි ආදානය සීමා කරන්න (අවශ්‍ය නොවන අවකාශ/ලකුණු ඉවත් කිරීම)

තාවකාලික විසඳුමක් ලෙස හොඳයි, ස්ථිර භාවිතයට සුදුසු නොවේ

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

7. සාමාන්‍ය වැරදි අවබෝධයන් සහ අසාර්ථකතා (LIKE සමඟ වෙනස්කම් / සංඛ්‍යාත්මක අගයන් සැකසීම)

FIND_IN_SET සරල ලෙස පෙනේ, නමුත් එය නිවැරදිව භාවිතා නොකළහොත් අනපේක්ෂිත ප්‍රතිඵල ලැබිය හැක.
මෙම කොටසේ, සාමාන්‍ය වාස්තු විශේෂ අවබෝධයන් සහ වැරදි, ඒවාට ප්‍රායෝගික විසඳුම් සමඟ සාකච්ඡා කරමු.

වැරදි 1: LIKE සහ FIND_IN_SET අතර වෙනස නොදැනීම

ඉතා සාමාන්‍ය වැරදි වන්නේ LIKE සහ FIND_IN_SET() අතර වෙනස නොදැනීමයි, එය වැරදි සෙවීමේ කොන්දේසි වෙත හේතු වේ.

-- Common incorrect usage
SELECT * FROM user_tags WHERE tags LIKE '%python%';

මෙම විමසුම පළමුව සත්‍ය ලෙස පෙනෙන්නට හැකි වුවත්, python උපස්තරය අඩංගු ඕනෑම දත්තයක් සමඟ ගැලපේ.

උදාහරණයක් ලෙස, එය "cpython", "pythonista" හෝ "java,pythonic" සමඟ ගැලපිය හැක, ඔබට එය අවශ්‍ය නොවිය හැක.
ඔබට php,python,sql වැනි කොමා-වෙන් කරන ලද ලැයිස්තුවේ “python” යන වෙන්වූ අගයක් පමණක් ගැලපීමට අවශ්‍ය නම්, අර්ධ-ගැලපීම LIKE වැරදි ධනාත්මක ප්‍රතිඵල ඇති කිරීමේ ඉහළ අවදානමක් ඇත.

“python” තමන්ගේම අගයක් ලෙස පවතින බව තහවුරු කිරීමට ඔබට අවශ්‍ය නම්, FIND_IN_SET() නිවැරදි මෙවලමයි.

-- Correct usage
SELECT * FROM user_tags WHERE FIND_IN_SET('python', tags);

වැරදි 2: සංඛ්‍යාත්මක අගයන් මත FIND_IN_SET භාවිතා කිරීම සහ ගැඹුරු අවුල

FIND_IN_SET ආර්ගුමෙන් දෙකම ස්ට්‍රින් ලෙස සැලකේ යැයි ගණන කරයි.

ඒ නිසා මෙවැනි දත්ත සමඟ, සංවර්ධකයින් කාලයක් පසු වරදින හැසිරීමක් සිදු කරයි:

-- tags column contains: 1,2,10,20
SELECT * FROM user_tags WHERE FIND_IN_SET(1, tags);

කිසිවෙක් 1 යනු 10 සමඟද ගැලපේ යැයි සිතිය හැක, නමුත් වාස්තු විශේෂයෙන්, FIND_IN_SET(1, '1,2,10,20') පළමු ස්ථානයේ “1” අංගය පමණක් ගැලපේ.

FIND_IN_SET අගයන් වෙන් කර සම්පූර්ණ සමානතාව පරීක්ෂා කරන බැවින්, 1 යනු 10 හෝ 21 වලින් වෙනස් වේ.

කෙසේ වෙතත්, සංවර්ධකයින් තවමත් මෙම හැසිරීම වැරදි ලෙස තේරුම්ගෙන “1” “10” සමඟ ගැලපේ යැයි සිතිය හැක.

උපදෙස්: අගයන් සදහා ස්ට්‍රින් ලෙස පැහැදිලිව සලකන්න, අසපසුභාවය සහ ගැඹුරු අවුල වැළැක්වීමට.

වැරදි 3: හිස් ඉඩ, පූර්ණ-පළල කොමා හෝ නව පේළි ගැලපීම වැළැක්වීම

FIND_IN_SET ඉතා සංවේදී වේ. දත්තය පහත සඳහන් ගැටළු ඇතුළත් නම්, ගැලපීම අසාර්ථක වේ:

• අගයන් අවට හිස් ඉඩ (අවකාශ, ටැබ්, නව පේළි)
• පූර්ණ-පළල කොමා (、)
• අනපේක්ෂිත උද්ධෘත ලකුණු (ද්විත්ව උද්ධෘත හෝ එකක උද්ධෘත)

උදාහරණය:

FIND_IN_SET('python', 'php, python ,sql')
-- => No match (because it becomes " python " with spaces)

ප්‍රතිකාර:

• ඇතුළත් කිරීමේදී TRIM() භාවිතයෙන් හිස් ඉඩ ඉවත් කරන්න
• REPLACE(tags, ' ', '') සමඟ ආදානය පෙර-සකසන්න
• ඉදිරිපසයේ ආදානය සීමා කරන්න (අවශ්‍ය නොවන ඉඩ/ලකුණු ඉවත් කරන්න)

සාරාංශය: FIND_IN_SET ආරක්ෂිතව භාවිතා කිරීමේ මූලික කරුණු

ඔබ FIND_IN_SET භාවිතා කරන විට මෙම හැසිරීම් නොදැන සිටිනවා නම්, “සෙවීම ක්‍රියා කරයි” යැයි සිතිය හැක, නමුත් වාස්තු විශේෂයෙන් අපේක්ෂිත ලේඛන ලබා නොගනී, එය ගැඹුරු දෝෂයන්ට හේතු විය හැක.

ඊළඟ කොටසේ, මෙම ගැටළු මූලිකව විසඳන “විකල්ප ක්‍රියාමාර්ග” ගැන අපි කතා කරමු.

8. FIND_IN_SET සඳහා විකල්ප (හොඳ පුරුදු)

FIND_IN_SET කොමා-වෙන් කරන ලද පදනම් මත සවිස්තරාත්මක සෙවීම් සක්‍රිය කරයි, නමුත් එය විශාල දත්ත කට්ටල හෝ විස්තාරණය අවශ්‍ය පද්ධති සඳහා සුදුසු නොවේ.
මෙම කොටසේ, FIND_IN_SET භාවිතය avoided කරන නිර්දේශිත විකල්ප (හොඳ පුරුදු) හඳුන්වා දෙමු.

සාමාන්‍යීකරණය කළ වගුව සැලසුමකට මාරු වන්න

අතිශය නිර්දේශිත ක්‍රමය වන්නේ දත්ත ගබඩාව සාමාන්‍යීකරණය කර, අගයන් තනි පේළි ලෙස කළමනාකරණය කිරීමයි.
එක කොමා-වෙන් කරන ලද තීරුවක බහු අගයන් ගබඩා කිරීම වෙනුවට, සම්බන්ධක වගුව (සම්බන්ධතා වගුව) භාවිතා කර බහු-බහු සම්බන්ධතා පැහැදිලිව නිරූපණය කරන්න.

උදාහරණය: පරිශීලකයන් සහ ටැග් අතර සම්බන්ධතාවය

සාම්ප්‍රදායික (අසාමාන්‍යීකරණ) ව්‍යුහය:

සාමාන්‍යීකරණ ව්‍යුහය:

users වගුව

tags වගුව

user_tag_relation (සම්බන්ධක වගුව)

මෙම ව්‍යුහය සමඟ, FIND_IN_SET භාවිතා නොකර JOIN භාවිතයෙන් සවිස්තරාත්මක සෙවීම් කළ හැක:

SELECT users.*
FROM users
JOIN user_tag_relation ON users.id = user_tag_relation.user_id
JOIN tags ON user_tag_relation.tag_id = tags.id
WHERE tags.name = 'python';

මෙම ක්‍රමය සුචක (index) සාර්ථකව ක්‍රියා කිරීමට ඉඩ සලසයි සහ කාර්ය සාධනය හා විස්තාරණය ගණනාවෙන් වැඩිදියුණු කරයි.

JSON වර්ගය භාවිතා කරන්න (MySQL 5.7+)

MySQL 5.7 සහ ඊට පසු, ඔබට JSON තීරුවල භාවිතා කළ හැක. කොමා-වෙන් කරන ලද පදනම් ගබඩා කිරීම වෙනුවට, අගයන් JSON අරේ ලෙස ගබඩා කර JSON ක්‍රියාකාරකම් භාවිතයෙන් සෙවිය හැක.

උදාහරණය:

["php", "python", "sql"]

සෙවීමේ උදාහරණය:

SELECT * FROM user_tags
WHERE JSON_CONTAINS(tags_json, '"python"');

මෙය ටැග් ව්‍යුහගත කරයි, හිස් ඉඩ නිසා ඇතිවන වැරදි ගැලපීම් වැළැක්වයි, සහ දත්ත ගුණාත්මක ගැටළු අඩු කරයි.
තවද, JSON-විශේෂිත සුචක (MySQL 8.0+) වැඩිදියුණු කාර්ය සාධනය ලබා දිය හැක.

යෙදුම් පාර්ශ්වයේ බෙදීම සහ නැවත ගොඩනැගීම

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

උදාහරණය (PHP):

$tags = explode(',', $record['tags']);
if (in_array('python', $tags)) {
    // Execute processing
}

මෙය දත්ත ගබඩා පාර්ශ්වයේ වැඩ බර අඩු කරයි සහ ආරක්ෂිත සැකසීම සක්‍රිය කරයි.

FIND_IN_SET “අප්‍රතික්ෂේප” ලෙස භාවිතා කරන්න, පෙරනිමි ලෙස නොව

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

9. FAQ: සාමාන්‍ය ප්‍රශ්න සහ පිළිතුරු

FIND_IN_SET සමඟ, වාස්තුකාර්ය සහ ඉගෙනීමේදී බොහෝ ප්‍රශ්න සහ ගැටළු උදාවී ඇත.
මෙහි, අපි සාමාන්‍යයෙන් අසන ප්‍රශ්න Q&A ආකාරයෙන් සංවිධානය කර ඇත, එය සාමාන්‍ය සෙවීම් අරමුණට හොඳින් ගැලපේ.

Q1. FIND_IN_SET භාවිතා කිරීම කවදා නිවැරදියි?

A.
FIND_IN_SET භාවිතා කරන්නේ විශේෂිත අගයක් කොමා-වෙන් කරන ලද පදනමක ඇතුළත්දැයි පරීක්ෂා කිරීමට අවශ්‍ය වන විටය.
එය පහත පරිදි අවස්ථා සඳහා සුදුසුය:

• සැලසුම එක තීරුවක බහු අගයන් ගබඩා කිරීම අවශ්‍ය වන විට (උදා: ටැග්, අවසර, කොඩි)
• ඔබට පරණ අසාමාන්‍යීකරණ දත්ත ගබඩාව වෙනස් නොකර සෙවීමට අවශ්‍ය වන විට
• භාවිතය සීමිත වන (පරිපාලක මෙවලම්, අභ්‍යන්තර තිර) කුඩා සිට මධ්‍යම දත්ත කට්ටල සඳහා

කෙසේ වෙතත්, එය මූලික නිෂ්පාදන සැකසීම හෝ විශාල පරිමාණ දත්ත සඳහා සුදුසු නොවේ.

Q2. FIND_IN_SET සහ LIKE අතර වෙනස කුමක්ද?

A.
LIKE '%value%' අර්ධ-ගැලපීමක් සිදු කරයි, එනම් උපස්ථානයට පෙර හෝ පසු යන අකුරු කිසිවක් නොසලකා ගනිමින් ගැලපිය හැක.
අනෙක් පැත්තට, FIND_IN_SET('value', comma_separated_string) කොමා-වෙන් කරන ලද එක් එක් අංගයට සම්පූර්ණ ගැලපීම මත සෙවීමක් කරයි.

-- LIKE example (matches anything containing "python")
tags LIKE '%python%'

-- FIND_IN_SET example (matches only "python" as an independent element)
FIND_IN_SET('python', tags)

‘python’ යන වචනය ‘cpython’ හෝ ‘pythonista’ වැනි වචන සමඟ ගැලපිය හැකි සාමාන්‍ය LIKE වැරදි එකකි.

Q3. FIND_IN_SET SQL විමසුම් මන්ද මන්දගාමී කරයි?

A.
FIND_IN_SET ඉන්ඩෙක්ස් භාවිතා නොකර සම්පූර්ණ පරික්ෂණයක් බල කරන ක්‍රියාකාරකමක් වන බැවින්.
එය සෑම පේළියක්ම පරීක්ෂා කර, අගයන් සැසඳීමට ස්ට්‍රින් විග්‍රහ කරයි; එබැවින් දත්ත ප්‍රමාණය වැඩි වීමත් සමඟ සැකසීමේ කාලය වේගයෙන් වැඩි වේ.

එබැවින් බොහෝ ලේඛන ඇති වගු වලදී මෙය ප්‍රධාන කාර්ය සාධන ගැටළු ඇති කරයි.

Q4. සංඛ්‍යා සෙවීමේදී “1” යන අගය “10” සමඟ ගැලපෙයිද?

A.
FIND_IN_SET සම්පූර්ණ ගැලපීම සිදු කරන බැවින්, සාමාන්‍යයෙන් “1” සහ “10” වෙන වෙනම අගයන් ලෙස සැලකේ.
කෙසේ වෙතත්, හිස් ඉඩ, ප්‍රකාර පරිවර්තනය, හෝ ආදාන ආකෘතියේ වෙනස්කම් ඇතිනම්, ප්‍රතිචාරය ඔබේ අපේක්ෂාවට අනුකූල නොවිය හැක.

-- Correct example
FIND_IN_SET('1', '1,2,10') -- => 1 (first position)

-- Commonly misunderstood example
FIND_IN_SET(1, '1,2,10') -- => also 1 (works, but is ambiguous)

උපදෙස්: අනිච්චිත හැසිරීමක් වැළැක්වීමට අගයන් ස්ට්‍රින් ලෙස සෑම විටම සලකන්න.

Q5. WordPress හි FIND_IN_SET භාවිත කළ හැකිද?

A.
meta_query වැනි සාමාන්‍ය WordPress විශේෂාංග මගින් FIND_IN_SET භාවිත කළ නොහැකි නමුත්, $wpdb සමඟ සෘජු SQL ක්‍රියාත්මක කිරීමෙන් එය භාවිත කළ හැක.

global $wpdb;
$sql = $wpdb->prepare("
  SELECT * FROM {$wpdb->prefix}postmeta
  WHERE meta_key = %s AND FIND_IN_SET(%s, meta_value)
", 'your_meta_key', 'search_value');

$results = $wpdb->get_results($sql);

කෙසේ වෙතත්, ඔබේ නිර්මාණය අභිරුචි ක්ෂේත්‍රවලට බරපතලව පදනම් වූ නම්, විකල්ප (උදාහරණයක් ලෙස බහු meta යතුරු කළමනාකරණය) ගැන සලකා බලන්න.

Q6. JSON තීරුවලින් වෙනස කුමක්ද? ඒවා FIND_IN_SET ට වඩා පහසුද?

A.
MySQL 5.7+ හි JSON තීරුව භාවිතා කිරීමෙන් දත්ත සංරචිතව තබා JSON_CONTAINS() මඟින් සෙවිය හැක.
ඒක නිරවද්‍යතාව, විස්තාරණය සහ සවිස්තරතාවය පිළිබඳව FIND_IN_SET ට සාමාන්‍යයෙන් වඩා උසස් වේ.

-- JSON search example
SELECT * FROM users WHERE JSON_CONTAINS(tags_json, '"python"');

නවීන නිර්මාණවල, FIND_IN_SET ට වඩා JSON තීරුවලට ප්‍රමුඛතාව දීම වැඩි වශයෙන් පවතිනවා.

10. නිගමනය: FIND_IN_SET “පහසු ව්‍යතිරේකයක්” වන අතර ඔබේ සැකැස්ම නැවත සලකා බැලීමට අවස්ථාවකි

මෙම ලිපියේ, අපි MySQL හි FIND_IN_SET() ක්‍රියාකාරකම — මූලික වාක්‍ය රීති, ප්‍රායෝගික උදාහරණ, වැරදි සහ නිර්දේශිත විකල්ප — පිළිබඳව සාකච්ඡා කළෙමු.

එය කුඩා ක්‍රියාකාරකමක් වැනි පෙනේද, නමුත් නිවැරදිව භාවිත කළහොත්, දත්ත ගබඩා මෙහෙයුම් වල ඔබට කළ හැකි දේවල් විහිදුවන ශක්තිමත් මෙවලමක් වේ.

FIND_IN_SET හි ප්‍රධාන ලක්ෂණ සමාලෝචනය

එය භාවිතයට සුදුසු අවස්ථා (හා භාවිත නොකළ යුතු අවස්ථා)

භාවිතයට සුදුසු අවස්ථා:

• දත්ත කට්ටලය කුඩා වන අතර භාවිතය සීමිතයි
• පරණ පද්ධති ප්‍රතිසංස්කරණය කිරීමට අමාරු වන අතර ඔබට ඉක්මන් විසඳුමක් අවශ්‍යයි
• පරිපාලක තිරවල හෝ කණ්ඩායම් සැකසීමේදී තාවකාලික විසඳුමක් අවශ්‍යයි

භාවිත නොකළ යුතු අවස්ථා:

• සෙවීමේ වේගය වැදගත් වන විශාල දත්ත කට්ටල
• නිතර යාවත්කාලීන, එකතු කිරීම, හෝ තත්ත්ව වෙනස්කම් අවශ්‍ය වන වැඩපිළිවෙළ
• දිගුකාලීන විස්තාරණය සහ නඩත්තු සඳහා සැලසුම් කරන ලද නිර්මාණ

FIND_IN_SET “පහසු ව්‍යතිරේකයක්” වේ. සැබෑ පිළිතුර වඩා හොඳ සැකැස්ම නිර්මාණයයි

FIND_IN_SET මූලික වශයෙන් ව්‍යුහීය සීමා ඇති විට පරිවර්තන විසඳුමක් වේ.
ඔබ නව සැකැස්මක් නිර්මාණය කරන්නේ නම්, මෙම දෙකේ විකල්ප දෙක සලකා බලන්න:

• සාමාන්‍යීකරණය දත්ත ගබඩාව සහ ජන්ක්ශන් වගුවක් සමඟ බහු-බහු සම්බන්ධතා කළමනාකරණය කරන්න
• ඔබට ලවච්චතාව අවශ්‍ය නම්, JSON තීරුව භාවිතා කර සංරචිත දත්ත ගබඩා කරන්න

මෙම ලිපිය FIND_IN_SET කවදා ප්‍රයෝජනවත්ද, එහි සීමා, සහ ස්කීමා නිර්මාණය නැවත සලකා බැලීම බොහෝ විට හොඳ විසඳුමක් යන දේ ඔබට හොඳින් තේරුම් ගැනීමට උදව් කරන්නේ නම්, එය ජයග්‍රහණයක් වේ.