ဒေတာဘေ့စ် Schema ဒီဇိုင်းဆွဲနည်း

နားလည်ထားရမယ့် အချက်

Database schema တစ်ခု ဒီဇိုင်းဆွဲခြင်းဟာ ချက်ချင်း idea တစ်ခုတည်းနဲ့ ပြီးတာ မဟုတ်ပါဘူး — ထပ်ခါထပ်ခါ လုပ်နိုင်တဲ့ ဆုံးဖြတ်ချက်တွေ အဆက်အစပ်ပါ။ ဒီအတိုင်းသဘောထားမှသာ production ထဲမှာ တည်တံ့တဲ့ schema နဲ့ ခြောက်လအတွင်း ပြန်ရေးရမယ့် schema ကို ခွဲခြားနိုင်မှာပါ။

Table တွေနဲ့ column တွေထဲ ချက်ချင်းမဆင်းသွားဘဲ၊ အတွေ့အကြုံရှိတဲ့ team တွေက requirements စုဆောင်းခြင်းမှ data အစစ်နဲ့ design ကို စမ်းသပ်ခြင်းအထိ အဆင့် ၉ ဆင့်ကို အမြဲတမ်း အတူတူ လုပ်ကြပါတယ်။

Query နဲ့ index တွေက အစမှာမဟုတ်ဘဲ အဆုံးနားမှာ ရောက်လာတာကို သတိပြုပါ — app က database ကို ဘာမေးမလဲသိမှသာ index ကောင်းကောင်းကို ရွေးနိုင်မှာပါ။

SCHEMA DESIGN WORKFLOW
----------------------
1. Requirements    -> what must the system do?
        |
2. Identify Entities -> User, Course, Lesson, Enrollment...
        |
3. Define Fields    -> attributes per entity
        |
4. Choose Keys      -> primary keys, foreign keys
        |
5. Define Relations -> one-to-many, many-to-many
        |
6. Add Constraints  -> required, unique, not null
        |
7. Design Queries   -> what will the app actually ask?
        |
8. Add Indexes      -> speed up those specific queries
        |
9. Test             -> real data, real queries, verify

လက်တွေ့ scenario နဲ့ ချိတ်ကြည့်မယ်

Workflow ကို learning platform တစ်ခုအပေါ် အသုံးချကြည့်ရင် ပိုတိကျလာပါတယ်။ Plain-English requirements အနည်းငယ်ထဲက entity တွေက တိုက်ရိုက် ပေါ်လာပါတယ်: User, Course, Lesson, Enrollment, Progress, Bookmark။

Constraint တွေက raw structure အပေါ်မှာ လက်တွေ့ စည်းမျဉ်း ထပ်ထည့်ပေးပါတယ် — Lesson တစ်ခုက Course တစ်ခုတည်းနဲ့ ပါဝင်ရမယ်၊ user တစ်ယောက် course တစ်ခုတည်းကို နှစ်ခါ enroll လုပ်လို့ မရသင့်ပါဘူး။

အောက်က code ဥပမာက step နှစ်ချက်ရဲ့ ရိုးရှင်းထားတဲ့ version ကို အသုံးချထားပါတယ် — requirements list ကို candidate entity list အဖြစ် ပြောင်းပေးတာပါ။ တမင်ရိုးရှင်းအောင် ဖန်တီးထားတာမို့ session အစစ်မှာတော့ ရှာတွေ့တာတွေကို လူတစ်ယောက်က review, merge, rename လုပ်ဖို့ လိုနေဆဲပါ။

• Schema design ဟာ idea တစ်ခုတည်းမဟုတ်ဘဲ ထပ်ခါထပ်ခါ လုပ်နိုင်တဲ့ အဆင့် ၉ ဆင့် workflow တစ်ခုပါ။
• Entity, key, relationship အစစ်တွေ ရှိပြီးမှသာ query နဲ့ index တွေက process အဆုံးနားမှာ ရောက်လာပါတယ်။
• Enrollment (သို့) Progress လို ရိုးရိုး relationship ထင်ရတဲ့ entity တွေဟာ extra field ရှိလားစစ်ကြည့်ရင် table သီးသန့် ထိုက်တန်တတ်ပါတယ်။

အတူတူ စမ်းရေးကြည့်မယ်

function extractCandidateEntities(requirements) {
  // Illustrative heuristic only -- NOT real NLP. It just looks for known
  // domain-noun keywords so you have a starting list to refine by hand.
  const knownNouns = {
    user: "user", users: "user",
    course: "course", courses: "course",
    lesson: "lesson", lessons: "lesson",
    enrollment: "enrollment", enrollments: "enrollment",
    progress: "progress",
    bookmark: "bookmark", bookmarks: "bookmark",
    instructor: "instructor", instructors: "instructor"
  };
  const nounPattern = new RegExp("\\b(" + Object.keys(knownNouns).join("|") + ")\\b", "gi");
  const counts = {};
  for (const req of requirements) {
    const matches = req.match(nounPattern) || [];
    for (const m of matches) {
      const key = knownNouns[m.toLowerCase()];
      counts[key] = (counts[key] || 0) + 1;
    }
  }
  return Object.entries(counts)
    .sort((a, b) => b[1] - a[1])
    .map(([entity, mentions]) => ({ entity, mentions }));
}

const requirements = [
  "Users can browse and enroll in courses",
  "Each course has multiple lessons in a fixed order",
  "The app tracks a user's progress through each lesson",
  "Users can bookmark a lesson to return to later",
  "Instructors create courses and lessons",
  "An enrollment links one user to one course"
];

console.log(JSON.stringify(extractCandidateEntities(requirements), null, 2));

Function က requirement string ခြောက်ခုကို scan လုပ်ပြီး သိထားတဲ့ domain keyword တစ်ခုစီကို ရေတွက်ကာ mention အရေအတွက်အလိုက် စီထားတဲ့ candidate entity list ကို ပြန်ပေးပါတယ်: user (4), course (4), lesson (4), progress (1), bookmark (1), instructor (1), enrollment (1)။ Trailing 's' ကို မသေချာဘဲ ဖြတ်ပစ်တာမျိုးမဟုတ်ဘဲ သိထားတဲ့ singular/plural form တွေကို တိတိကျကျ map လုပ်ထားတာမို့ 'progress' ကို 'progres' ဖြစ်သွားတဲ့ ရိုးရာ stemming bug ကို ရှောင်နိုင်ပါတယ်။

Wikipedia: Database design — How Databases Work