Chapter 21: Database နှင့် SQL (Databases and SQL)

အရင်အခန်းတွေမှာ file handling ကို လေ့လာခဲ့ပြီးပြီ။ File ထဲမှာ data သိမ်းတာ သေးငယ်တဲ့ program တွေအတွက် အဆင်ပြေပေမယ့်၊ data များလာရင်၊ လူအများကြီး တပြိုင်နက် သုံးရင်၊ data တွေ မပျောက်အောင် စနစ်တကျ ထိန်းသိမ်းချင်ရင် file တစ်ခုတည်းနဲ့ မလုံလောက်တော့ဘူး။

ဒီအခန်းမှာ database ဆိုတာ ဘာလဲ၊ DBMS ဆိုတာ ဘာလဲ၊ ဘာကြောင့် လိုအပ်တာလဲဆိုတာ လေ့လာမယ်။ ပြီးရင် database တွေကို ထိန်းချုပ်တဲ့ ဘာသာစကား SQL ကို လက်တွေ့ စမ်းသပ်ကြည့်မယ်။ ဒီအခန်းက နောက်အခန်းမှာ Python နဲ့ MySQL ချိတ်ဆက်မယ့် အပိုင်းအတွက် အခြေခံအုတ်မြစ် ဖြစ်တယ်။

1. Database ဆိုတာဘာလဲ (What is a Database)

မင်းရဲ့ ဖုန်းထဲက contact list ကို စဉ်းစားကြည့်ပါ။ နာမည်တွေ၊ ဖုန်းနံပါတ်တွေကို စနစ်တကျ စီစဉ်ထားတယ်။ ရှာချင်တဲ့ နာမည်ကို ရိုက်လိုက်တာနဲ့ ချက်ချင်း တွေ့တယ်။ အသစ်ထည့်မယ်၊ ပြင်မယ်၊ ဖျက်မယ် — အားလုံး လွယ်လွယ်ကူကူ လုပ်နိုင်တယ်။

အဲဒီလိုပဲ database ဆိုတာ စနစ်တကျ စီစဉ်ထားတဲ့ data (သတင်းအချက်အလက်) တွေရဲ့ စုစည်းမှုတစ်ခုပါ။ Database တစ်ခုကို ပုံမှန်အားဖြင့် DBMS (Database Management System) လို့ ခေါ်တဲ့ software က ထိန်းချုပ်ထားတယ်။ DBMS ရှိလို့ data တွေကို လွယ်လွယ်ကူကူ ရှာဖွေနိုင်တယ်၊ စီမံနိုင်တယ်၊ ပြင်ဆင်နိုင်တယ်၊ update လုပ်နိုင်တယ်၊ ထိန်းချုပ်နိုင်တယ်၊ စနစ်တကျ ထားနိုင်တယ်။

Data နဲ့ Information (Data vs Information)

ဒီစကားလုံးနှစ်လုံးကို ရောထွေးတတ်ကြတယ်။ ကွာခြားချက်ကို သိထားဖို့ အရေးကြီးတယ်။

Data	Information
စနစ်တကျ မစီစဉ်ရသေးတဲ့ အချက်အလက် အစိမ်းတွေ (unorganised, unrefined facts)	အဓိပ္ပာယ်ရှိတဲ့ အကြောင်းအရာအဖြစ် စီစဉ်ပြသထားတဲ့ data (organised data in a meaningful context)
အဓိပ္ပာယ် မပါတဲ့ ကုန်ကြမ်းလိုပဲ (raw materials)	အဓိပ္ပာယ် ပါဝင်တဲ့ data အစုအဝေး
Information ကို မှီခိုစရာ မလိုဘူး	Data ကို မှီခိုပြီး ဖြစ်ပေါ်လာတယ်
bits နဲ့ bytes နဲ့ တိုင်းတာတယ်	အချိန်၊ ပမာဏ စတဲ့ အဓိပ္ပာယ်ရှိတဲ့ ယူနစ်တွေနဲ့ တိုင်းတာတယ်
ဆုံးဖြတ်ချက် ချဖို့ မလုံလောက်ဘူး	ဆုံးဖြတ်ချက် ချဖို့ လုံလောက်တယ်

ဥပမာ — "25, 30, 28" ဆိုတာ data သက်သက်ပဲ။ ဘာကိုဆိုလိုမှန်း မသိဘူး။ ဒါပေမယ့် "ဒီအပတ်မှာ ရန်ကုန်ရဲ့ အမြင့်ဆုံးအပူချိန်တွေက ၂၅၊ ၃၀၊ ၂၈ ဒီဂရီ" ဆိုရင်တော့ အဓိပ္ပာယ် ပေါ်လာပြီ — ဒါ information ဖြစ်သွားပြီ။

Database ရဲ့ အလုပ်က data အစိမ်းတွေကို စနစ်တကျ သိမ်းထားပြီး၊ လိုအပ်တဲ့အခါ information အဖြစ် ထုတ်ပေးဖို့ပဲ။

Database ဘာကြောင့် လိုအပ်သလဲ (Why do we need a database?)

Database ထဲမှာ သတင်းအချက်အလက် သိမ်းတာက အကျိုးကျေးဇူးတွေ အများကြီး ရှိတယ်။

• နည်းမျိုးစုံနဲ့ စီစဉ်၊ ဆန်းစစ်နိုင်တယ် — report တွေ ထုတ်တာ၊ စာပို့လိပ်စာ စာရင်းလုပ်တာ၊ ကုန်ပစ္စည်း စာရင်း (inventory) ထိန်းတာမျိုး
• တခြားနည်းတွေထက် သာလွန်တယ် — မြန်တယ် (speed)၊ စိတ်ချရတယ် (reliability)၊ တိကျတယ် (precision)၊ အလုပ်တွေကို အလိုအလျောက် လုပ်ခိုင်းနိုင်တယ် (automation)
• သတင်းအချက်အလက် ပြန်ရှာရတာ မြန်ပြီး လွယ်ကူတယ် — လိုချင်တဲ့ data ကို ချက်ချင်း ဆွဲထုတ်နိုင်တယ်
• အမြောက်အမြား သိမ်းနိုင်တယ် — data များလေလေ database သုံးရတဲ့ အကျိုးကျေးဇူး ကြီးလေလေပဲ
• စီစဉ်တာ၊ ပြန်စီစဉ်တာ လွယ်ကူတယ် — data ပုံစံပြောင်းချင်ရင် အလွယ်တကူ ပြင်နိုင်တယ်

Reference

• MySQL Downloads — ဒီအခန်းမှာ လေ့လာတဲ့ သဘောတရားတွေကို ကိုယ်တိုင်စမ်းသပ်ချင်ရင် MySQL ကို ဒီကနေ ရယူနိုင်တယ်
• Python + MySQL (W3Schools) — နောက်အခန်းမှာ Python နဲ့ database ချိတ်ဆက်ပုံကို အသေးစိတ် ဆက်လေ့လာနိုင်တယ်

2. File နဲ့ သိမ်းတာ ဘာကြောင့် မလုံလောက်သလဲ (Why files are not enough)

အခန်း ၂၀ မှာ file ထဲမှာ data သိမ်းတာ လေ့လာခဲ့တယ်။ လူတစ်ယောက်တည်း သုံးတဲ့ သေးငယ်တဲ့ program အတွက်တော့ file က လုံလောက်တယ်။ ဒါပေမယ့် လက်တွေ့ဘဝမှာ data ပမာဏ ကြီးလာရင် file နဲ့တင် မလုံလောက်တော့ဘူး။ ဘာကြောင့်လဲ ကြည့်ရအောင်။

ပြဿနာ	ရှင်းလင်းချက်
Redundancy	တူညီတဲ့ data ကို နေရာအများကြီးမှာ မိတ္တူကူးပြီး သိမ်းထားရတာ
Inconsistency	မိတ္တူတွေအချင်းချင်း မကိုက်ညီတော့တာ (တချို့နေရာမှာ အဟောင်း၊ တချို့နေရာမှာ အသစ်)
Hard to access	လိုချင်တဲ့ data ကို ရှာဖို့ search algorithm ကိုယ်တိုင် ရေးရတာ — အရမ်းခက်၊ အရမ်းနှေး
Unauthorized access	File ထဲက data ကို ဘယ်သူ ဘာလုပ်ခွင့်ရှိလဲဆိုတာ အဆင့်ဆင့် ထိန်းချုပ်ဖို့ ခက်တာ
No concurrent access	တချိန်တည်းမှာ လူအများကြီး တူညီတဲ့ file ကို သုံးဖို့ အပြည့်အဝ မရတာ
No backup and recovery	File ပျက်သွားရင်၊ ပျောက်သွားရင် backup လုပ်ပြီး ပြန်ရယူတဲ့ စနစ် မပါတာ

ဥပမာ စဉ်းစားကြည့်ပါ။ ဆိုင်တစ်ဆိုင်က ဖောက်သည်စာရင်းကို customers.txt ဆိုတဲ့ file နဲ့ သိမ်းထားတယ်။ ဝန်ထမ်းသုံးယောက်က တချိန်တည်းမှာ အဲဒီ file ကို ဖွင့်ပြီး ပြင်နေရင် ဘာဖြစ်မလဲ? တစ်ယောက်ရဲ့ ပြင်ဆင်ချက်က နောက်တစ်ယောက်ရဲ့ ပြင်ဆင်ချက်ကို ဖျက်ပစ်မိမယ်။ ဒါ no concurrent access ပြဿနာပဲ။

ဒါ့အပြင် ဖောက်သည်တစ်ယောက်ရဲ့ ဖုန်းနံပါတ် ပြောင်းသွားလို့ customers.txt မှာ ပြင်လိုက်တယ်။ ဒါပေမယ့် ရောင်းအားစာရင်း file ထဲမှာတော့ ဖုန်းနံပါတ် အဟောင်းပဲ ကျန်နေတယ်။ ဒါ inconsistency ပဲ။

Database တွေက ဒီပြဿနာတွေအားလုံးကို ဖြေရှင်းပေးဖို့ တည်ဆောက်ထားတာပါ။

Reference

• MySQL Downloads — file system ရဲ့ ပြဿနာတွေကို database က ဘယ်လို ဖြေရှင်းပေးလဲဆိုတာ ကိုယ်တိုင် စမ်းသပ်ကြည့်နိုင်တယ်
• Python + MySQL (W3Schools) — database အခြေခံ အဆင့်တွေကို လက်တွေ့ ဥပမာတွေနဲ့ လေ့လာနိုင်တယ်

3. DBMS က ဘယ်လိုအလုပ်လုပ်သလဲ (How a DBMS works)

CRUD — Data နဲ့ လုပ်တဲ့ အခြေခံလုပ်ငန်း ၄ ခု

Database နဲ့ လုပ်တဲ့ အလုပ်အားလုံးကို အခြေခံလုပ်ငန်း ၄ ခုအဖြစ် ချုံ့နိုင်တယ်။ ဒါကို CRUD လို့ ခေါ်တယ်။

• Create — data အသစ် ဖန်တီးထည့်သွင်းတာ
• Read — data ကို ဖတ်ရှုထုတ်ယူတာ
• Update — ရှိပြီးသား data ကို ပြင်ဆင်တာ
• Delete — data ကို ဖျက်ပစ်တာ

Program တစ်ခု (application) က database ကနေ data ယူချင်ရင် ကိုယ့်ဘာသာစကား (ဥပမာ Python) နဲ့ တောင်းဆိုတယ်။ အဲဒီတောင်းဆိုချက်က DBMS ကို ရောက်တယ်။ DBMS က data တွေကို ဘယ်လို စုဆောင်း၊ သိမ်း၊ စီမံ၊ အသုံးချမလဲဆိုတာ database model နဲ့ သတ်မှတ်ထားတဲ့ စည်းမျဉ်းတွေအတိုင်း ဆောင်ရွက်ပေးတယ်။ ပြီးမှ တကယ့် data ဆီကနေ အဖြေကို ပြန်ယူပေးတယ်။

↻ ပြန်ဖွင့်ရန်

Table, Record, Field (Database Organization)

Database တစ်ခုကို table တစ်ခု ဒါမှမဟုတ် အများကြီး နဲ့ ဖွဲ့စည်းထားတယ်။ Table တစ်ခုချင်းစီထဲမှာ record တွေ သိမ်းထားတယ်။ Record တစ်ခုချင်းစီကတော့ field တွေရဲ့ စုစည်းမှုပဲ။

နားလည်လွယ်အောင် လိပ်စာစာအုပ် (address book) နဲ့ ဥပမာပေးရအောင်။

• လိပ်စာစာအုပ်တစ်ခုလုံး = database တစ်ခု
• လူတစ်ယောက်ချင်းစီရဲ့ အချက်အလက် (နာမည် + လိပ်စာ + ဖုန်း) = record တစ်ခု
• နာမည်၊ လိပ်စာ၊ ဖုန်း ဆိုတဲ့ အကွက်တစ်ခုချင်းစီ = field တစ်ခု

Table အဖြစ် မြင်ရင် ဒီလိုမျိုး ဖြစ်မယ်။

name (field)	address (field)	phone (field)
Ma Hla (record)	Yangon	09-771234567
Ko Min (record)	Mandalay	09-887654321

အပေါ်က ဇယားမှာ row တစ်ခုချင်းစီက record တစ်ခု၊ column တစ်ခုချင်းစီက field တစ်ခု ဖြစ်တယ်။

DBMS ရဲ့ အခန်းကဏ္ဍ (The role of a DBMS)

DBMS ဆိုတာ database နဲ့ အဲဒါကို သုံးတဲ့ လူ (ဒါမှမဟုတ် program) တွေကြားက ကြားခံမျက်နှာပြင် (interface) ပါ။ DBMS က ဒါတွေ လုပ်ပေးတယ်။

• User တွေ data ကို ပြန်ရှာတာ၊ update လုပ်တာ၊ သတင်းအချက်အလက် ဘယ်လို စီစဉ်ပြီး အကောင်းဆုံး ဖြစ်အောင် လုပ်မလဲဆိုတာ စီမံပေးတယ်
• Data ကို ဘယ်လို သိမ်း၊ ဘယ်လို ပြန်ရှာမလဲဆိုတာ database model နဲ့ သတ်မှတ်ပေးတယ်
• Database တွေကို ကြီးကြပ်ထိန်းချုပ်ပေးတယ် — performance ကို စောင့်ကြည့်တာ၊ မြန်အောင် ညှိတာ (tuning)၊ backup လုပ်တာ၊ ပျက်သွားရင် ပြန်ရယူတာ (recovery) စတဲ့ စီမံခန့်ခွဲရေး လုပ်ငန်းတွေ လုပ်ပေးတယ်

တိုတိုပြောရရင် DBMS ဆိုတာ database ရဲ့ အုပ်ထိန်းသူ၊ စောင့်ရှောက်သူ၊ ဝန်ဆောင်မှုပေးသူပဲ။

Database Model တွေအကြောင်း

Database model ဆိုတာ database တစ်ခုရဲ့ ယုတ္တိကျတဲ့ ဖွဲ့စည်းပုံကို ပြတာ — data တွေအချင်းချင်း ဘယ်လို ဆက်စပ်တယ်၊ ဘယ်လို စည်းမျဉ်းတွေနဲ့ သိမ်းမယ်/ထုတ်မယ်ဆိုတာ သတ်မှတ်ပေးတယ်။ အဓိက model တွေ ရှိတယ်။

• Hierarchical model — data တွေကို သစ်ပင်လို အဆင့်ဆင့် ဖွဲ့ထားတာ (အဖေ → သား ဆက်စပ်မျိုး)
• Network model — record တွေ အချင်းချင်း လမ်းကြောင်းအမျိုးမျိုးနဲ့ ဆက်ထားတာ
• Relational model — data ကို table တွေအဖြစ် သိမ်းတာ (ဒီနေ့ခေတ် အသုံးအများဆုံး)
• Object-oriented model — OOP က object တွေအတိုင်း data သိမ်းတာ
• NoSQL model — table ပုံစံ မဟုတ်ဘဲ တခြားပုံစံတွေနဲ့ သိမ်းတာ

ဒီအခန်းမှာ အရေးအကြီးဆုံးဖြစ်တဲ့ relational model ကို အသေးစိတ် ဆက်လေ့လာမယ်။

Reference

• MySQL Downloads — relational database စနစ်တစ်ခုကို ကိုယ့်စက်မှာ အခမဲ့ စမ်းသပ်နိုင်တယ်
• Python + MySQL (W3Schools) — DBMS နဲ့ ဘယ်လို ဆက်သွယ်ရမလဲဆိုတဲ့ အခြေခံကို လေ့လာနိုင်တယ်

4. Relational Model နဲ့ MySQL (The Relational Model and MySQL)

E.F. Codd နဲ့ Relational Model

Relational model ကို E.F. Codd ဆိုသူက အဆိုပြုခဲ့တယ်။ သူ့စိတ်ကူးက data တွေကို relation (ဆက်စပ်မှု) ပုံစံနဲ့ စီမံမယ်ဆိုတာပဲ — လက်တွေ့မှာတော့ ဒါ table တွေပဲ ဖြစ်တယ်။

Codd ရဲ့ model က record တစ်ခုကို table တစ်ခုထက်ပိုပြီး ဆက်စပ်ခွင့် ပေးတယ်။ ဒါ့ကြောင့် many-to-many ဆက်စပ်မှုမျိုး (ဥပမာ ကျောင်းသားတစ်ယောက်က ဘာသာရပ် အများကြီး ယူတယ်၊ ဘာသာရပ်တစ်ခုမှာလည်း ကျောင်းသား အများကြီး ရှိတယ်) ကို ဖော်ပြနိုင်တယ်။

Codd က relational data ကို စီမံဖို့ Alpha ဆိုတဲ့ ဘာသာစကားကိုလည်း အဆိုပြုခဲ့တယ်။ နောက်ပိုင်းမှာ ဒါကနေ ဆင့်ကဲဖြစ်ပေါ်လာတာက SQL ပဲ။ ဆိုလိုတာက SQL ရဲ့ အမြစ်က Codd ရဲ့ အတွေးအခေါ်ပဲ။

Relation ရဲ့ သဘောတရားများ (Concepts of the Relational Model)

Concept	ရှင်းလင်းချက်
Domain	Attribute တစ်ခုက ယူနိုင်တဲ့ အက်တမ် တန်ဖိုး (atomic value) တွေရဲ့ အစု — column တစ်ခုရဲ့ ဖြစ်နိုင်တဲ့ တန်ဖိုးတွေ
Attribute	Relation တစ်ခုကို သတ်မှတ်ပေးတဲ့ ဂုဏ်သတ္တိ — table ထဲက column ရဲ့ နာမည်
Tuple	Attribute တွေရဲ့ အစု — record တစ်ခု ပါဝင်တဲ့ table ရဲ့ row တစ်ခု
Key	Tuple တစ်ခုကို တစ်မူထူး ခွဲခြားနိုင်တဲ့ attribute (ဥပမာ ကျောင်းသားရဲ့ ID နံပါတ်)
Degree	Relation တစ်ခုထဲက attribute (column) အရေအတွက်
Cardinality	Relation တစ်ခုထဲက tuple (row) အရေအတွက်

ဥပမာ — column ၄ ခု၊ row ၁၀ ခု ရှိတဲ့ table တစ်ခုဆို degree = 4၊ cardinality = 10 ဖြစ်တယ်။

↻ ပြန်ဖွင့်ရန်

Database တွေရဲ့ ဆင့်ကဲဖြစ်စဉ် (Evolution of Databases)

• 1960s — Hierarchical database နဲ့ Network database (navigational database လို့လည်း ခေါ်တယ်)
• 1980s — Relational database တွေ ပေါ်ထွန်းလာတယ်
• 1990s — Object-oriented database တွေ ထွက်လာတယ်
• 2009 — NoSQL database တွေ စတင်ခေတ်စားလာတယ်
• ယနေ့ခေတ် — Cloud database နဲ့ Self-driving database (ကိုယ့်ဘာသာ စီမံခန့်ခွဲနိုင်တဲ့ database) တွေ

MySQL ဆိုတာဘာလဲ (What is MySQL?)

MySQL ရဲ့ မူရင်းဗားရှင်းကို SEQUEL (Structured English Query Language) လို့ ခေါ်ခဲ့တယ်။ နောက်ပိုင်း SQL (Structured Query Language) ဆိုတာ relational database တွေကို ဖန်တီးပြီး လုပ်ဆောင်ချက်တွေ လုပ်နိုင်တဲ့ ဘာသာစကားအဖြစ် ဖြစ်လာတယ်။ SQL က table တွေထဲမှာ သိမ်းထားတဲ့ ဆက်စပ်သတင်းအချက်အလက် အစုတွေကို ကိုင်တွယ်နိုင်တယ်။

MySQL ကို Windows၊ Linux၊ Mac အားလုံးမှာ သုံးနိုင်တယ်။

MySQL ရဲ့ ထူးခြားချက်များ

• လုပ်ငန်းစဉ်ကို အဆင့်ဆင့် ညွှန်စရာမလိုတဲ့ (non-procedural) အင်္ဂလိပ်လို ဘာသာစကား — "ဘာလုပ်ချင်လဲ" ဆိုတာပဲ ပြောရတယ်
• အခမဲ့ ရနိုင်တဲ့ database system
• Data ကို table တွေထဲမှာ သိမ်းတယ်၊ table တွေက data ကို row နဲ့ column တွေနဲ့ သိမ်းတယ်
• Row သန်း ၅၀ ကျော်အထိ ကိုင်တွယ်နိုင်တဲ့ အရွယ်အစား (scalable)
• ထူးခြားတဲ့ storage engine ဗိသုကာကြောင့် ပိုမြန်တယ်၊ ပိုသက်သာတယ်၊ ပိုစိတ်ချရတယ်

Reference

• MySQL Downloads — MySQL Community Edition ကို အခမဲ့ ဒေါင်းလုဒ်လုပ်ပြီး ဒီအခန်းက SQL တွေကို ကိုယ်တိုင် စမ်းသပ်ပါ
• Python + MySQL (W3Schools) — SQL အခြေခံကို လက်တွေ့ ဥပမာတွေနဲ့ ဆက်လေ့လာနိုင်တယ်

5. SQL လက်တွေ့ — စာအုပ်ဆိုင် တစ်ခု တည်ဆောက်ကြည့်မယ် (Hands-on SQL)

သဘောတရားတွေ လုံလောက်ပြီ။ အခု လက်တွေ့ စမ်းကြည့်မယ်။ စိတ်ကူးကြည့်ပါ — မင်းက အွန်လိုင်းစာအုပ်ဆိုင် တစ်ခု ဖွင့်ထားတယ်။ ဆိုင်ထဲက စာအုပ်တွေကို database နဲ့ စီမံချင်တယ်။

Database ဖန်တီးခြင်း

CREATE DATABASE bookshop_db;
USE bookshop_db;

CREATE DATABASE bookshop_db; က bookshop_db ဆိုတဲ့ database အသစ် တစ်ခု ဖန်တီးပေးတယ်။ USE bookshop_db; ကတော့ "အခု ဒီ database ကို သုံးမယ်" လို့ ပြောတာပဲ။ စာအုပ်တစ်အုပ်ကို ဖွင့်လိုက်သလို စဉ်းစားနိုင်တယ်။

Table တည်ဆောက်ခြင်း

CREATE TABLE books (
    id INT PRIMARY KEY AUTO_INCREMENT,
    title VARCHAR(100),
    author VARCHAR(60),
    price INT,
    stock INT
);

ဒီ command က books ဆိုတဲ့ table တစ်ခု တည်ဆောက်ပေးတယ်။ Column တစ်ခုချင်းစီကို ကြည့်ရအောင်။

• id INT PRIMARY KEY AUTO_INCREMENT — စာအုပ်တိုင်းကို တစ်မူထူး ခွဲခြားပေးတဲ့ နံပါတ်။ PRIMARY KEY ဆိုတာ တန်ဖိုးထပ်လို့ မရဘူး၊ လွတ်လို့လည်း မရဘူးဆိုတဲ့ အာမခံချက်။ AUTO_INCREMENT ဆိုတာ data အသစ်ထည့်တိုင်း နံပါတ် အလိုအလျောက် တိုးသွားတာ (1, 2, 3...) — ကိုယ်တိုင် နံပါတ်ပေးစရာ မလိုဘူး။
• title VARCHAR(100) — စာအုပ်နာမည်။ VARCHAR(100) ဆိုတာ စာလုံးရေ ၁၀၀ အထိ ရတဲ့ စာသားအမျိုးအစား။
• author VARCHAR(60) — စာရေးသူ နာမည်။
• price INT — ဈေးနှုန်း (ကျပ်)။
• stock INT — လက်ကျန် အရေအတွက်။

Table နဲ့ ဖွဲ့စည်းပုံ ကြည့်ခြင်း

SHOW TABLES;

+-----------------------+
| Tables_in_bookshop_db |
+-----------------------+
| books                 |
+-----------------------+

DESCRIBE books;

+--------+--------------+------+-----+---------+----------------+
| Field  | Type         | Null | Key | Default | Extra          |
+--------+--------------+------+-----+---------+----------------+
| id     | int          | NO   | PRI | NULL    | auto_increment |
| title  | varchar(100) | YES  |     | NULL    |                |
| author | varchar(60)  | YES  |     | NULL    |                |
| price  | int          | YES  |     | NULL    |                |
| stock  | int          | YES  |     | NULL    |                |
+--------+--------------+------+-----+---------+----------------+

DESCRIBE က table ရဲ့ ဖွဲ့စည်းပုံ (column နာမည်၊ အမျိုးအစား၊ key ဟုတ်/မဟုတ်) ကို ပြပေးတယ်။

Data ထည့်သွင်းခြင်း (INSERT)

INSERT INTO books (title, author, price, stock)
VALUES ('The Alchemist', 'Paulo Coelho', 15000, 20);

INSERT INTO books (title, author, price, stock)
VALUES ('Atomic Habits', 'James Clear', 22000, 15),
       ('Dune', 'Frank Herbert', 28000, 8);

ပထမ command က စာအုပ်တစ်အုပ် ထည့်တယ်။ ဒုတိယ command က တစ်ခါတည်း နှစ်အုပ် ထည့်တယ် — VALUES နောက်မှာ ကော်မာနဲ့ ခွဲပြီး အစုံလိုက် ရေးလို့ရတယ်။ id ကို မထည့်တာ သတိထားမိ့မလား? AUTO_INCREMENT ကြောင့် MySQL က 1, 2, 3 ဆိုပြီး အလိုအလျောက် ပေးသွားတယ်။

Data ထုတ်ယူခြင်း (SELECT)

Table ထဲက data အားလုံး ကြည့်ချင်ရင်။

SELECT * FROM books;

+----+---------------+---------------+-------+-------+
| id | title         | author        | price | stock |
+----+---------------+---------------+-------+-------+
|  1 | The Alchemist | Paulo Coelho  | 15000 |    20 |
|  2 | Atomic Habits | James Clear   | 22000 |    15 |
|  3 | Dune          | Frank Herbert | 28000 |     8 |
+----+---------------+---------------+-------+-------+

* ဆိုတာ "column အားလုံး" လို့ အဓိပ္ပာယ်ရတယ်။ Column အချို့ပဲ လိုချင်ရင် နာမည်ကို တိတိကျကျ ပြောလို့ရတယ်။

SELECT title, author FROM books;

+---------------+---------------+
| title         | author        |
+---------------+---------------+
| The Alchemist | Paulo Coelho  |
| Atomic Habits | James Clear   |
| Dune          | Frank Herbert |
+---------------+---------------+

အခြေအနေ (condition) နဲ့ စစ်ထုတ်ချင်ရင် WHERE သုံးတယ်။

SELECT * FROM books WHERE price > 20000;

+----+---------------+---------------+-------+-------+
| id | title         | author        | price | stock |
+----+---------------+---------------+-------+-------+
|  2 | Atomic Habits | James Clear   | 22000 |    15 |
|  3 | Dune          | Frank Herbert | 28000 |     8 |
+----+---------------+---------------+-------+-------+

ဈေး ၂၀၀၀၀ ကျော်တဲ့ စာအုပ်တွေပဲ ထွက်လာတယ်။

Data ပြင်ဆင်ခြင်း (UPDATE)

'Dune' စာအုပ်ရဲ့ လက်ကျန် ၈ အုပ်ကနေ ၂၅ အုပ် ဖြစ်သွားပြီဆိုပါစို့။

UPDATE books
SET stock = 25
WHERE title = 'Dune';

SET က ဘယ် field ကို ဘာတန်ဖိုးနဲ့ ပြင်မလဲဆိုတာ ပြောတယ်။ WHERE က ဘယ် record (ဘယ် row) ကို ပြင်မလဲဆိုတာ ရွေးပေးတယ်။

Data ဖျက်ပစ်ခြင်း (DELETE)

id = 2 ဖြစ်တဲ့ စာအုပ်ကို ဆိုင်ကနေ ဖယ်ချင်ရင်။

DELETE FROM books
WHERE id = 1;

Reference

• MySQL Downloads — အပေါ်က SQL command တွေအားလုံးကို MySQL မှာ ကိုယ်တိုင် ရိုက်စမ်းကြည့်ပါ — လက်တွေ့လုပ်မှ တတ်မှာ
• Python + MySQL (W3Schools) — SQL အခြေခံကို ဥပမာအပိုတွေနဲ့ ဆက်လေ့လာနိုင်တယ်

လေ့ကျင့်ခန်းများ

1. Database နဲ့ table တည်ဆောက်ခြင်း — library_db ဆိုတဲ့ database တစ်ခု ဖန်တီးပြီး၊ အထဲမှာ readers ဆိုတဲ့ table တစ်ခု တည်ဆောက်ပါ။ Column တွေက id (INT, PRIMARY KEY, AUTO_INCREMENT)၊ name (VARCHAR(80))၊ phone (VARCHAR(20))၊ member_since (INT — ဥပမာ 2024) ဖြစ်ရမယ်။ CREATE DATABASE နဲ့ CREATE TABLE command တွေ ရေးပါ။

2. Data vs Information — ကိုယ့်နေ့စဉ်ဘဝထဲက data သက်သက်ရဲ့ ဥပမာ ၃ ခု၊ information ဖြစ်သွားတဲ့ ဥပမာ ၃ ခု ရေးပြပါ။

3. File system ရဲ့ အားနည်းချက် — ကျောင်းတစ်ကျောင်းက ကျောင်းသားစာရင်းကို Excel file တစ်ခုတည်းနဲ့ သိမ်းထားတယ်ဆိုပါစို့။ ဒီအခန်းက ပြဿနာ ၆ ခု (redundancy၊ inconsistency၊ hard to access၊ unauthorized access၊ no concurrent access၊ no backup and recovery) ထဲက ဘယ်ဟာတွေ ကြုံရနိုင်လဲဆိုတာ ဥပမာနဲ့တကွ ရှင်းပြပါ။

4. SELECT with WHERE — ဒီအခန်းက books table ကို သုံးပြီး ဈေး ၂၀၀၀၀ အောက် စာအုပ်တွေရဲ့ title နဲ့ stock ကို ထုတ်တဲ့ SQL query တစ်ခု ရေးပါ။

5. အန္တရာယ်ရှိတဲ့ query — UPDATE books SET price = 30000; ဆိုတဲ့ command မှာ WHERE မပါဘူး။ ဒါကို run မိရင် ဘာဖြစ်သွားမလဲဆိုတာ ရှင်းပြပြီး၊ ဘယ်လို ပြင်ရေးသင့်လဲဆိုတာ ရေးပြပါ။