SQL Queries (SQL query များ)

A3.3.1: Outline the differences between data language types within SQL. A3.3.2: Construct queries between two tables in SQL. A3.3.4: Construct calculations within a database using SQL’s aggregate functions (HL).
မြန်မာလို: A3.3.1: SQL ထဲက data language အမျိုးအစားတွေ၊ ဆိုလိုတာက DDL (database ဖွဲ့စည်းပုံကို သတ်မှတ်တဲ့ SQL အပိုင်း) နဲ့ DML (ဒေတာကို ဖတ်၊ ပြင်တဲ့ SQL အပိုင်း) ကြားက ကွာခြားချက်တွေကို outline (အကျဉ်းချုပ် ဖော်ပြ) လုပ်နိုင်ရပါမယ်။ A3.3.2: table (database ထဲက ဇယား) နှစ်ခုကို သုံးတဲ့ SQL query (database ထဲက ဒေတာကို ရှာ၊ ပြင်ဖို့ ပေးတဲ့ အမိန့်) တွေကို construct (ကိုယ်တိုင် တည်ဆောက်) လုပ်နိုင်ရပါမယ်။ A3.3.4: SQL ရဲ့ aggregate function (row အများကနေ တန်ဖိုး တစ်ခု တွက်တဲ့ SQL function) တွေကို သုံးပြီး database ထဲမှာ တွက်ချက်မှုတွေကို construct လုပ်နိုင်ရပါမယ် (HL)။ ဒါတွေက IB Computer Science (နိုင်ငံတကာ ကျောင်းတွေမှာ သင်တဲ့ ကွန်ပျူတာသိပ္ပံ သင်ရိုး) ထဲက ခေါင်းစဉ် နံပါတ်တွေပါ။ SL (Standard Level) နဲ့ HL (Higher Level) ဆိုတာ IB သင်တန်းရဲ့ အဆင့်နှစ်ဆင့်ဖြစ်ပြီး (HL) လို့ ရေးထားတဲ့ အပိုင်းကို HL မှာပဲ လေ့လာရပါတယ်။

အဓိက အယူအဆများ

SQL ဆိုတာ ဘာလဲ

SQL (Structured Query Language) ဆိုတာ relational database (table တွေ ချိတ်ဆက်ထားတဲ့ database) တွေအတွက် စံ language ပါ။ Relational DBMS (database ကို စီမံပေးတဲ့ software) အားလုံးနီးပါး၊ ဥပမာ MySQL၊ PostgreSQL၊ SQL Server၊ Oracle၊ SQLite တို့က SQL ကို သုံးကြပြီး သူတို့ကြားမှာ ရေးပုံ ကွာခြားချက် အနည်းငယ်ပဲ ရှိပါတယ်။

SQL က declarative (လိုချင်တာကိုပဲ ဖော်ပြပြီး လုပ်ပုံကို မရေးရတဲ့) language ပါ: ကိုယ်လိုချင်တဲ့ ဒေတာက ဘာလဲ ဆိုတာကိုပဲ ဖော်ပြရပြီး အဲဒီ ဒေတာကို ဘယ်လို ယူရမလဲ ဆိုတာ မရေးရပါဘူး။ ဘယ်လို run မလဲ ဆိုတဲ့ နည်းလမ်းကို DBMS ရဲ့ query planner (query ကို ဘယ်လို run မလဲ ဆုံးဖြတ်ပေးတဲ့ အစိတ်အပိုင်း) က ရွေးပါတယ်။ ဒါကြောင့် query တစ်ခုတည်းကို စာလုံး တစ်လုံးမှ မပြောင်းဘဲ database တစ်ခုမှာ မြန်မြန် run ပြီး နောက် database တစ်ခုမှာ နှေးနှေး run နိုင်ပါတယ်: schema (database ဖွဲ့စည်းပုံ ဖော်ပြချက်)၊ index (ရှာတာ မြန်အောင် လုပ်ထားတဲ့ ညွှန်းစာရင်း) တွေနဲ့ ဒေတာ ပမာဏ အားလုံးက query ရဲ့ မြန်နှုန်းကို သက်ရောက်လို့ပါ။

DDL နဲ့ DML နှိုင်းယှဉ်ချက် (A3.3.1)

SQL ကို language အမျိုးအစား နှစ်မျိုး ခွဲထားပြီး အဲဒီ နှစ်မျိုးကို ခွဲခြားသိဖို့ လိုပါတယ်:

Language အမျိုးအစား အပြည့်အစုံ အမည် ဘာလုပ်လဲ အဓိက command များ
DDL Data Definition Language Database ရဲ့ ဖွဲ့စည်းပုံ ကို သတ်မှတ်ပါတယ်၊ table နဲ့ index တွေကို ဖန်တီး၊ ပြင်ဆင် ဒါမှမဟုတ် ဖျက်ပစ်ပါတယ် CREATE TABLE, ALTER TABLE, DROP TABLE, CREATE INDEX, DROP INDEX
DML Data Manipulation Language ဖွဲ့စည်းပုံ ထဲက ဒေတာ ကို ဖတ်ပြီး ပြင်ဆင်ပါတယ် SELECT, INSERT, UPDATE, DELETE

တခြား အမျိုးအစား နှစ်မျိုးလည်း ရှိပါတယ် (DCL က permission (သုံးခွင့်) တွေအတွက်ပါ၊ GRANT, REVOKE။ TCL က transaction (အကုန်ဖြစ် ဒါမှမဟုတ် ဘာမှမဖြစ်တဲ့ database လုပ်ဆောင်ချက် အစု) တွေအတွက်ပါ၊ BEGIN, COMMIT, ROLLBACK)။ ဒါပေမယ့် သေချာ လေ့လာထားသင့်တဲ့ အဓိက ခွဲခြားချက်က DDL နဲ့ DML ပါ။ TCL ကို HL မှာ Transactions and Views စာမျက်နှာမှာ သီးခြား လေ့လာရပါတယ်။

အသုံးဝင်တဲ့ စစ်နည်း: command (ကွန်ပျူတာကို ပေးတဲ့ ညွှန်ကြားချက်) က database ရဲ့ ပုံသဏ္ဌာန် (table၊ column (ဒေါင်လိုက် ကော်လံ)၊ index) ကို ပြောင်းရင် DDL ပါ။ ပါဝင်တဲ့ အကြောင်းအရာ (ဒေတာ row (အလျားလိုက် အတန်း) တွေ) ကို ပြောင်းရင် DML ပါ။

အလုပ်လုပ်တဲ့ ရိုးရှင်းတဲ့ ဥပမာ

ဒီစာမျက်နှာ တစ်လျှောက်လုံး အောက်က 3NF (third normal form: normalisation ရဲ့ တတိယ အဆင့်) schema ကို သုံးပါမယ်။ ဒါက Relational Database Fundamentals စာမျက်နှာက Harbour Run အားကစား အသင်းပါ၊ normalisation (ဒေတာ ထပ်မနေအောင် table တွေကို စီစဉ်ခြင်း) လုပ်ပြီး 3NF အထိ ရောက်အောင် ပြင်ထားပါတယ်:

-- Created with DDL
CREATE TABLE Member (
    MemberID    INT PRIMARY KEY,
    FirstName   VARCHAR(50)  NOT NULL,
    Surname     VARCHAR(50)  NOT NULL,
    DateOfBirth DATE         NOT NULL,
    Tier        VARCHAR(20)  NOT NULL
);

CREATE TABLE Class (
    ClassID  VARCHAR(8)   PRIMARY KEY,
    Title    VARCHAR(80)  NOT NULL,
    Coach    VARCHAR(60)  NOT NULL,
    StartsAt DATETIME     NOT NULL,
    Capacity INT          NOT NULL
);

CREATE TABLE Booking (
    BookingID VARCHAR(8)  PRIMARY KEY,
    MemberID  INT         NOT NULL,
    ClassID   VARCHAR(8)  NOT NULL,
    BookedOn  DATE        NOT NULL,
    Status    VARCHAR(20) NOT NULL,
    FOREIGN KEY (MemberID) REFERENCES Member(MemberID),
    FOREIGN KEY (ClassID)  REFERENCES Class(ClassID)
);

အပေါ်က CREATE TABLE statement (code ထဲက ညွှန်ကြားချက်) သုံးခုက DDL ပါ။ ဒီစာမျက်နှာရဲ့ ကျန်တဲ့ အပိုင်းက SELECT query တွေက DML ပါ။ ကျန်တဲ့ DML command တွေ ဖြစ်တဲ့ INSERT, UPDATE နဲ့ DELETE ကို SQL Updates မှာ လေ့လာရပါမယ်။

SELECT Statement ရဲ့ ဖွဲ့စည်းပုံ

SELECT query တစ်ခုမှာ clause (keyword တစ်ခုနဲ့ စတဲ့ statement ရဲ့ အပိုင်း) ခုနစ်ခုအထိ ပါနိုင်ပြီး သတ်မှတ်ထားတဲ့ အစဉ်အတိုင်း ရေးရပါတယ်။ Clause တိုင်းကို အမြဲ ထည့်ဖို့ မလိုပါဘူး၊ ဒါပေမယ့် clause အများ ပါလာရင် ဒီအစဉ်အတိုင်း ရေးရပါမယ်:

SELECT    [DISTINCT] columns
FROM      tables (with JOINs)
WHERE     row-level conditions
GROUP BY  grouping columns                 -- aggregate queries only
HAVING    group-level conditions           -- aggregate queries only
ORDER BY  sort columns [ASC | DESC]
LIMIT     row count                        -- optional, not strictly required

ဒီ block ထဲက English စာတွေက ဒီလို ဆိုလိုပါတယ်: columns (ရွေးမယ့် column တွေ)၊ tables (with JOINs) (JOIN တွေနဲ့ ချိတ်ထားတဲ့ table တွေ)၊ row-level conditions (row တစ်ခုချင်းအပေါ် စစ်တဲ့ condition တွေ)၊ grouping columns (group ဖွဲ့မယ့် column တွေ)၊ group-level conditions (group တစ်ခုချင်းအပေါ် စစ်တဲ့ condition တွေ)၊ sort columns (စီမယ့် column တွေ)၊ row count (ပြမယ့် row အရေအတွက်)။ -- aggregate queries only က aggregate query တွေမှာပဲ သုံးတယ်လို့ ဆိုလိုပြီး -- optional, not strictly required က ထည့်ချင်မှ ထည့်ရတယ်လို့ ဆိုလိုပါတယ်။ [ ] ထဲက အပိုင်းတွေကိုလည်း ထည့်ချင်မှ ထည့်ရပါတယ်။

Clause တစ်ခုစီက သူ့ရှေ့က clause တွေ ထုတ်ပေးခဲ့တာကို filter (condition နဲ့ ကိုက်တာတွေကိုပဲ ရွေးထုတ်ခြင်း) လုပ်တာ ဒါမှမဟုတ် ပုံစံ ပြောင်းတာ လုပ်ပါတယ်။ DBMS က အကြမ်းဖျင်းအားဖြင့် FROM -> WHERE -> GROUP BY -> HAVING -> SELECT -> ORDER BY အစဉ်နဲ့ တွက်ပါတယ်။

SELECT နဲ့ FROM: အခြေခံများ

အရိုးရှင်းဆုံး SELECT statement မှာ column တွေနဲ့ table တစ်ခုရဲ့ နာမည်ကို ရေးပါတယ်:

SELECT FirstName, Surname FROM Member;

SELECT * က column အားလုံးကို ပြန်ပေးပါတယ်။ တကယ် သုံးမယ့် code မှာ ရှောင်ပါ (နောက်မှ column အသစ် ထည့်ရင် ရလဒ် ပြောင်းသွားလို့ပါ)၊ ဒါပေမယ့် ဒေတာကို အမြန် ကြည့်ချင်တဲ့အခါ အသုံးဝင်ပါတယ်။

SELECT * FROM Member;

WHERE (row တွေကို filter လုပ်ခြင်း)

WHERE က condition (မှန်လား မှားလား စစ်တဲ့ အခြေအနေ) နဲ့ မကိုက်တဲ့ row တွေကို ဖယ်ထုတ်ပါတယ်။ အသုံးများတဲ့ operator (တန်ဖိုးတွေကို တွက်ချက်တဲ့ သင်္ကေတ) များ:

Operator ဥပမာ
= <> WHERE Tier = 'Premium', WHERE Status <> 'cancelled'
< <= > >= WHERE Capacity >= 20
BETWEEN ... AND ... WHERE BookedOn BETWEEN '2026-05-01' AND '2026-05-31'
IN (...) WHERE Tier IN ('Premium', 'VIP')
LIKE '...%...' WHERE Surname LIKE 'K%' (pattern match: ပုံစံနဲ့ ကိုက်မကိုက် စစ်ခြင်း)
IS NULL / IS NOT NULL WHERE Coach IS NULL (Coach မှာ တန်ဖိုး မရှိတဲ့ row တွေ။ ဒီ schema မှာ Coach ကို NOT NULL လို့ သတ်မှတ်ထားလို့ ဒီမှာတော့ တစ်ခုမှ ရှာမတွေ့ပါဘူး)

Boolean operator (condition တွေကို ပေါင်းစပ်ပေးတဲ့ operator) တွေ ဖြစ်တဲ့ AND, OR, NOT က condition တွေကို ပေါင်းပေးပါတယ်။ သူတို့ကို ရောသုံးတဲ့အခါ operator precedence (ဘယ် operator ကို အရင် တွက်မလဲ ဆိုတဲ့ စည်းမျဉ်း) ထင်ရှားအောင် ကွင်း ( ) တွေ သုံးပါ။

SELECT FirstName, Surname
FROM Member
WHERE Tier = 'Premium' AND DateOfBirth < '2005-01-01';

LIKE နဲ့ % wildcard (ဘယ် character မဆို အစားထိုးနိုင်တဲ့ သင်္ကေတ)

LIKE က string (စာသား) တစ်ခုကို pattern (ပုံစံ) တစ်ခုနဲ့ ကိုက်မကိုက် စစ်ပါတယ်။ % wildcard က character (စာလုံး ဒါမှမဟုတ် သင်္ကေတ) ဘယ်နှစ်လုံးမဆို (တစ်လုံးမှ မရှိတာလည်း ရ) လို့ ဆိုလိုပါတယ်။ _ (SL မှာ မလိုသလောက်ပါ) က character အတိအကျ တစ်လုံး လို့ ဆိုလိုပါတယ်။

Pattern ကိုက်ညီတာ
'K%' K နဲ့ စတာ (Kahurangi, Knight)
'%berg' berg နဲ့ ဆုံးတာ
'%ohan%' ဘယ်နေရာမှာမဆို ohan ပါတာ
'_ohan' character တစ်လုံးပြီးရင် ohan လာတာ (Mohan, Tohan) 
SELECT FirstName, Surname
FROM Member
WHERE Surname LIKE 'K%';

ORDER BY (ရလဒ်ကို စီခြင်း)

ORDER BY က output (program က ထုတ်ပြတဲ့ ရလဒ်) ကို စီပေးပါတယ်။ ASC က ascending order (ငယ်ရာကနေ ကြီးရာ) ပါ (ဘာမှ မရေးရင် ဒါကို သုံးပါတယ်)၊ DESC က descending order (ကြီးရာကနေ ငယ်ရာ) ပါ။ Column အများနဲ့ စီလို့ရပါတယ်: တန်ဖိုး တူနေတဲ့ row တွေကို စာရင်းထဲက နောက် column နဲ့ ဆက်စီပါတယ်။

SELECT FirstName, Surname, DateOfBirth
FROM Member
ORDER BY Surname ASC, FirstName ASC;

DISTINCT (ထပ်နေတာတွေကို ဖယ်ခြင်း)

SELECT DISTINCT က ရလဒ်ထဲမှာ ထပ်နေတဲ့ row တွေကို တစ်ခုတည်း ဖြစ်အောင် ပေါင်းပေးပါတယ်:

SELECT DISTINCT Coach FROM Class;     -- each coach appears once

(Code ထဲက comment ရဲ့ အဓိပ္ပာယ်: coach (နည်းပြ) တစ်ယောက်ချင်းစီ တစ်ကြိမ်ပဲ ပေါ်ပါတယ်။)

JOIN (table နှစ်ခုကို ပေါင်းစပ်ခြင်း)

JOIN က table နှစ်ခုက row တွေကို ကိုက်ညီတဲ့ column တစ်ခုပေါ် အခြေခံပြီး တွဲပေးပါတယ်။ အဲဒီ column က များသောအားဖြင့် foreign key (တခြား table ရဲ့ primary key ကို ညွှန်းတဲ့ column) နဲ့ primary key (row တစ်ခုချင်းကို ခွဲခြားပေးတဲ့ key) ကြားက ချိတ်ဆက်မှုပါ။ အနည်းဆုံး table နှစ်ခု ကို join လုပ်တဲ့ query ကို ရေးနိုင်ရပါမယ်။

ခေတ်သစ် explicit (ထင်ရှားအောင် ရေးထားတဲ့) syntax (code ရေးထုံး)၊ ဒါကို ပိုသုံးသင့်ပါတယ်:

SELECT Member.FirstName, Member.Surname, Class.Title
FROM Member
INNER JOIN Booking ON Member.MemberID = Booking.MemberID
INNER JOIN Class   ON Booking.ClassID = Class.ClassID
WHERE Class.StartsAt > '2026-06-01';

(အဲဒီ query က table သုံးခုကို join လုပ်ထားပါတယ်။ Table နှစ်ခုပဲ ဆိုရင် INNER JOIN တစ်ခုတည်း သုံးပါ။)

ပုံစံဟောင်း implicit (မရေးဘဲ ချန်ထားတဲ့) syntax (ဒါလည်း မှန်ပါတယ်၊ code အဟောင်းတွေမှာ အတွေ့ရများပါတယ်):

SELECT Member.FirstName, Booking.ClassID
FROM Member, Booking
WHERE Member.MemberID = Booking.MemberID
  AND Member.Tier = 'Standard';

Implicit ပုံစံမှာ FROM ထဲမှာ table တွေကို comma နဲ့ ခြားပြီး ရေးကာ join condition ကို WHERE ထဲမှာ ထည့်ပါတယ်။ Explicit INNER JOIN ... ON ... ပုံစံက join လုပ်ပုံကို filter လုပ်ပုံနဲ့ ခွဲထားလို့ query ကြီးတွေမှာ ဖတ်ရ ပိုလွယ်ပါတယ်။ ပုံစံ နှစ်မျိုးလုံး မှန်ကန်တဲ့ SQL ပါ: table တွေ၊ join condition နဲ့ filter တူတူ ရေးရင် row တွေ အတူတူ ပြန်ပေးပါတယ်။

Qualified column names (table နာမည် တပ်ထားတဲ့ column နာမည်များ)။ Table နှစ်ခုမှာ column နာမည် တူနေရင် (Member ရော Booking မှာပါ MemberID ရှိတာမျိုး) Member.MemberID ဒါမှမဟုတ် Booking.MemberID လို့ qualify (column နာမည်ရှေ့မှာ table နာမည် ထည့်ရေး) လုပ်ရပါမယ်။ Table နာမည် မတပ်ထားတဲ့ MemberID ကို DBMS က လက်မခံပါဘူး၊ ဘယ် column ကို ဆိုလိုမှန်း မသိလို့ပါ။

Table နှစ်ခုသုံး query ပြည့်ပြည့်စုံစုံမှာ ပါရမယ့် အရာများ

Table နှစ်ခုအကြောင်း မေးခွန်းကို ဖြေတဲ့ query မှာ အပိုင်း လေးပိုင်း ပါပါတယ်:

  1. မေးခွန်းက တောင်းတဲ့ column တွေ။
  2. Join လုပ်ထားတဲ့ table နှစ်ခုလုံး။
  3. Join condition: foreign key ကို သူညွှန်းတဲ့ primary key နဲ့ ကိုက်ပေးတဲ့ condition။
  4. မေးခွန်းထဲက ကန့်သတ်ချက် တစ်ခုစီအတွက် condition တစ်ခုစီ။

မပြီးခင် ကိုယ့် query ကို ဒီစာရင်းနဲ့ တိုက်စစ်ပါ။

GROUP BY နဲ့ HAVING (ဒေတာကို အနှစ်ချုပ်ခြင်း)

GROUP BY က column တစ်ခုမှာ တန်ဖိုး တူနေတဲ့ row တွေကို အနှစ်ချုပ် row တစ်ခုတည်း ဖြစ်အောင် ပေါင်းပေးပါတယ်။ Aggregate function တွေ (COUNT, SUM, AVG, MIN, MAX) နဲ့ တွဲသုံးပါ။ HAVING က အဲဒီ group (အုပ်စု) တွေကို filter လုပ်ပါတယ် (WHERE က FROM အတွက် လုပ်ပေးတာကို HAVING က GROUP BY အတွက် လုပ်ပေးပါတယ်)။

SELECT ClassID, COUNT(*) AS BookingCount
FROM Booking
GROUP BY ClassID
HAVING COUNT(*) > 10
ORDER BY BookingCount DESC;

အပေါ်က query က class (အားကစား လေ့ကျင့်ရေး သင်တန်း) တစ်ခုစီရဲ့ booking (class တက်ဖို့ ကြိုတင် စာရင်းသွင်းမှု) အရေအတွက်ကို ရေတွက်ပြီး booking 10 ခုထက် ပိုတဲ့ class တွေကိုပဲ ထားကာ booking အရေအတွက်အလိုက် အများဆုံးကနေ စီပါတယ်။

WHERE က group မဖွဲ့ ခင် run ပါတယ် (row တွေကို ဖယ်ပါတယ်)။ HAVING က group ဖွဲ့ ပြီးမှ run ပါတယ် (group တွေကို ဖယ်ပါတယ်)။ အဖြစ်များတဲ့ အမှားက aggregate condition (aggregate function ပါတဲ့ condition) ကို WHERE ထဲ ထည့်တာပါ။ WHERE အဆင့်မှာ aggregate တန်ဖိုးတွေ မရှိသေးလို့ DBMS က လက်မခံပါဘူး။

Aggregate Functions (row အများကနေ တန်ဖိုး တစ်ခု တွက်တဲ့ SQL function များ) (A3.3.4၊ HL အတွက်သာ)

A3.3.4 က HL အတွက်ပဲ ဖြစ်တဲ့ learning statement (သင်ရိုးက လေ့လာရမယ့် အချက်) ပါ။ SL ကျောင်းသားတွေက ဒီ function တွေကို မြင်ရင် သိရပါမယ်၊ ဒါပေမယ့် သူတို့ကို သုံးပြီး query တွေ construct လုပ်ဖို့ မလိုပါဘူး။

သိထားသင့်တဲ့ aggregate function ငါးခု:

Function ပြန်ပေးတဲ့ တန်ဖိုး
COUNT(col) Column ထဲက null (တန်ဖိုး မရှိခြင်း) မဟုတ်တဲ့ တန်ဖိုး အရေအတွက်။ COUNT(*) က null ပါတဲ့ row တွေ အပါအဝင် row အားလုံးကို ရေတွက်ပါတယ်။ COUNT(DISTINCT col) က မတူတဲ့ တန်ဖိုးတွေကို ရေတွက်ပါတယ်၊ ဒါကြောင့် နှစ်ကြိမ် ပေါ်တဲ့ တန်ဖိုးကို တစ်ကြိမ်ပဲ ရေတွက်ပါတယ်။
SUM(col) Column ထဲက တန်ဖိုးတွေရဲ့ ပေါင်းလဒ်။ ဂဏန်း column တွေမှာပဲ အလုပ်လုပ်ပါတယ်။
AVG(col) Column ထဲက တန်ဖိုးတွေရဲ့ ပျမ်းမျှ (arithmetic mean)။ IB သင်ရိုးက AVERAGE လို့ ခေါ်ပေမယ့် SQL မှာ AVG လို့ ရေးပါတယ်။
MIN(col) အငယ်ဆုံး တန်ဖိုး (ဂဏန်း၊ ရက်စွဲ ဒါမှမဟုတ် အက္ခရာစဉ်အရ)။
MAX(col) အကြီးဆုံး တန်ဖိုး (ဂဏန်း၊ ရက်စွဲ ဒါမှမဟုတ် အက္ခရာစဉ်အရ)။

ဒီ function တွေကို များသောအားဖြင့် ပုံစံ နှစ်မျိုးနဲ့ သုံးပါတယ်:

ပုံစံ 1: table တစ်ခုလုံးအပေါ် aggregate (output row တစ်ခု):

SELECT COUNT(*) AS TotalMembers,
       MIN(DateOfBirth) AS Oldest,
       MAX(DateOfBirth) AS Youngest
FROM Member;

ပုံစံ 2: group အလိုက် aggregate (group တစ်ခုကို row တစ်ခု):

SELECT Tier, COUNT(*) AS MembersInTier
FROM Member
GROUP BY Tier;

အသင်းဝင် 921 ယောက် ရှိတဲ့ အသင်းအတွက် output နမူနာ:

Tier MembersInTier
Premium 312
Standard 588
VIP 21

HAVING ထည့်ရင် group တွေကိုယ်တိုင်ကို filter လုပ်ပါတယ်:

SELECT Coach, MAX(Capacity) AS LargestClass
FROM Class
GROUP BY Coach
HAVING MAX(Capacity) >= 20
ORDER BY LargestClass DESC;

ဒီ query က သူ့ရဲ့ အကြီးဆုံး class မှာ အနည်းဆုံး လူ 20 ဆံ့တဲ့ coach တစ်ယောက်ချင်းစီကို ပြပြီး အကြီးဆုံးကနေ စီပါတယ်။

BETWEEN၊ IN နဲ့ ရက်စွဲ အပိုင်းအခြားများ

BETWEEN ... AND ... က >= နဲ့ <= စစ်ချက် နှစ်ခုကို အတိုချုပ် ရေးတာပါ။ အစွန်း နှစ်ဖက်လုံး ပါဝင်ပါတယ် (inclusive)။ BookedOn မှာ ရက်စွဲပဲ သိမ်းထားလို့ ဒီ query က 2026 ဇွန်လမှာ လုပ်ခဲ့တဲ့ booking အားလုံးကို ရှာပေးပါတယ်:

SELECT BookingID, BookedOn
FROM Booking
WHERE BookedOn BETWEEN '2026-06-01' AND '2026-06-30';

StartsAt မှာ ရက်စွဲရော အချိန်ပါ သိမ်းထားပါတယ်။ '2026-06-30' လို ရက်စွဲ သက်သက်က အဲဒီနေ့ စတဲ့ ညသန်းခေါင် အချိန်ကို ဆိုလိုပါတယ်။ ဒါကြောင့် StartsAt BETWEEN '2026-06-01' AND '2026-06-30' က ဇွန် 30 ရက် 18:00 နာရီက class ကို ချန်ထားခဲ့ပါလိမ့်မယ်။ ရက်စွဲနဲ့ အချိန် သိမ်းတဲ့ column မှာ တစ်လလုံးကို လိုချင်ရင် လရဲ့ ပထမနေ့နဲ့ နောက်လရဲ့ ပထမနေ့ကို နှိုင်းယှဉ်ပါ:

SELECT Title, StartsAt
FROM Class
WHERE StartsAt >= '2026-06-01' AND StartsAt < '2026-07-01';

နေ့ တစ်နေ့ရဲ့ ဘယ်အချိန်မဆို လိုချင်ရင် နောက်နေ့နဲ့ ပုံစံ တူတူ သုံးပါ: StartsAt >= '2026-06-01' AND StartsAt < '2026-06-02'။

IN (...) က စာရင်းထဲက ဘယ်တန်ဖိုးနဲ့ပဲ တူတူ ကိုက်ပါတယ်:

SELECT FirstName, Surname
FROM Member
WHERE Tier IN ('Premium', 'VIP');

SQL Query တွေမှာ အဖြစ်များတဲ့ အမှားများ

  • = အစား == သုံးခြင်း။ SQL မှာ တူမတူ စစ်တာက equals sign (=) တစ်ခုတည်းပါ။ == က programming language တွေကနေ ပါလာတဲ့ အကျင့်ပါ: SQLite က လက်ခံပေမယ့် MySQL နဲ့ PostgreSQL က query ကို လက်မခံပါဘူး။
  • ဂဏန်း literal (code ထဲမှာ တိုက်ရိုက် ရေးထားတဲ့ တန်ဖိုး) တွေကို quote (' ') ထဲ ထည့်ခြင်း။ WHERE Capacity = '20' လို့ မရေးဘဲ WHERE Capacity = 20 လို့ ရေးပါ: quote တွေက ဂဏန်းကို စာသား ဖြစ်သွားစေပြီး DBMS က အဲဒါကို ဂဏန်း ပြန်ပြောင်းရပါတယ်။
  • စာသားကို double quote နဲ့ ရေးခြင်း။ စာသား တန်ဖိုး တွေအတွက် single quote ('Premium') ကို သုံးပါ။ Standard SQL မှာ double quote တွေက column နဲ့ table နာမည်တွေအတွက်ပါ၊ ဒါကြောင့် PostgreSQL က "Premium" ကို column နာမည်လို့ ဖတ်ပြီး query ကို လက်မခံပါဘူး။
  • WHERE ထဲမှာ aggregate ထည့်ခြင်း။ WHERE COUNT(*) > 5 က မမှန်ပါဘူး၊ HAVING ကို သုံးပါ။
  • Table နာမည် မတပ်ထားလို့ ဝေဝါးနေတဲ့ column များ။ Join လုပ်ထားတဲ့ table နှစ်ခုလုံးမှာ MemberID ရှိနေရင် ခွဲခြားဖို့ Member.MemberID လို့ ရေးရပါမယ်။
  • Semicolon မေ့ခြင်း။ Statement တိုင်းကို ; နဲ့ အဆုံးသတ်ပါ။ Semicolon က statement တစ်ခု ဘယ်မှာ ဆုံးပြီး နောက်တစ်ခု ဘယ်မှာ စလဲ ဆိုတာကို ပြပါတယ်။ Tool တော်တော်များများက statement တစ်ခုတည်းကို semicolon မပါဘဲ run ပေးပေမယ့် statement အများကို စာရင်းလိုက် ရေးရင် လိုအပ်ပါတယ်။

အဆင့်ဆင့် ရှင်းပြထားတဲ့ ဥပမာများ

ဥပမာ 1: WHERE နဲ့ ORDER BY ပါတဲ့ table တစ်ခုတည်း SELECT

Premium tier (အသင်းဝင် အဆင့်) ရှိတဲ့ အသင်းဝင် အားလုံးရဲ့ ပထမ နာမည် (first name)၊ မျိုးရိုး နာမည် (surname) နဲ့ tier ကို မျိုးရိုး နာမည်အလိုက် အက္ခရာစဉ်နဲ့ စီပြီး ပြပါ။

SELECT FirstName, Surname, Tier
FROM Member
WHERE Tier = 'Premium'
ORDER BY Surname ASC;

ပြည့်စုံတဲ့ အဖြေမှာ ပါရမယ့် အရာများ:

  • SELECT column စာရင်း။
  • Tier ပေါ်က WHERE filter။
  • Surname ပေါ်က ORDER BY clause။

ဥပမာ 2: Compound (condition အများ ပေါင်းထားတဲ့) WHERE ပါတဲ့ table နှစ်ခု JOIN

2000 ခုနှစ် ဒါမှမဟုတ် အဲဒီနောက်ပိုင်း မွေးတဲ့ အသင်းဝင်တွေက 2026 မေ 30 ရက် မတိုင်ခင် လုပ်ခဲ့တဲ့ booking တိုင်းအတွက် booking ID၊ class ID နဲ့ tier ကို ပြပါ။

မွေးနေ့နဲ့ tier က Member ထဲမှာ ရှိပါတယ်။ Booking ID၊ class ID နဲ့ booking လုပ်ခဲ့တဲ့ ရက်စွဲက Booking ထဲမှာ ရှိပါတယ်။ ဒါကြောင့် query က table နှစ်ခုကို MemberID နဲ့ join လုပ်ပြီး table တစ်ခုစီပေါ်မှာ condition တစ်ခုစီ ထားပါတယ်:

SELECT Booking.BookingID, Booking.ClassID, Member.Tier
FROM Member
INNER JOIN Booking ON Member.MemberID = Booking.MemberID
WHERE Member.DateOfBirth >= '2000-01-01'
  AND Booking.BookedOn < '2026-05-30';

Trace the Query အပိုင်းက နမူနာ table တွေနဲ့ဆိုရင် ရလဒ်က row တစ်ခုပါ: B9001, C401, Standard (Aroha ရဲ့ booking)။ Priya ကလည်း 2000 နောက်ပိုင်း မွေးပေမယ့် သူမရဲ့ booking ကို မေ 30 ရက်မှာ လုပ်ခဲ့တာမို့ မေ 30 ရက် မတိုင်ခင် မဟုတ်ပါဘူး။

ပြည့်စုံတဲ့ အဖြေမှာ ပါရမယ့် အရာများ:

  • Column သုံးခု၊ တစ်ခုစီကို သူ့ကို သိမ်းထားတဲ့ table ကနေ ယူထားတာ။
  • Join လုပ်ထားတဲ့ table နှစ်ခုလုံး။
  • Join condition Member.MemberID = Booking.MemberID။
  • WHERE ထဲက condition နှစ်ခုလုံး၊ AND နဲ့ ပေါင်းထားတာ။

ဥပမာ 3: LIKE နဲ့ pattern match လုပ်ခြင်းနဲ့ condition အများ

ခေါင်းစဉ် (title) မှာ “Sunrise” ဆိုတဲ့ စကားလုံး ပါပြီး မျိုးရိုး နာမည် “O” နဲ့ စတဲ့ coach က သင်ပေးကာ 2026 ဇွန်လမှာ စတဲ့ class တိုင်းကို ပြပါ။

SELECT ClassID, Title, Coach, StartsAt
FROM Class
WHERE Title LIKE '%Sunrise%'
  AND Coach LIKE '% O%'
  AND StartsAt >= '2026-06-01' AND StartsAt < '2026-07-01';

Pattern '% O%' က နာမည်ထဲမှာ space (ကွက်လပ်) တစ်ခုပြီးရင် O လာတဲ့ coach နဲ့ ကိုက်ပါတယ် (“Lila Okafor” လို နာမည်မျိုး)။ နောက်ဆုံး line က ဇွန် 30 ရက် နေ့ရဲ့ နောက်ပိုင်း အချိန်တွေက class တွေ အပါအဝင် ဇွန်လ တစ်လလုံးကို ဖုံးပါတယ်၊ ဘာလို့လဲဆိုတော့ StartsAt မှာ ရက်စွဲအပြင် အချိန်ပါ သိမ်းထားလို့ပါ။

ဥပမာ 4 (HL): GROUP BY နဲ့ HAVING ပါတဲ့ aggregate

Coach တစ်ယောက်ချင်းစီအတွက် သူ့ class တွေကို 2026 ဇွန်လမှာ လုပ်ခဲ့တဲ့ booking အရေအတွက်ကို ရေတွက်ပါ၊ ဒါပေမယ့် booking အနည်းဆုံး 50 ခု ရှိတဲ့ coach တွေကိုပဲ ပြပါ။ Booking အရေအတွက်အလိုက် အများဆုံးကနေ စီပါ။

SELECT Class.Coach, COUNT(*) AS BookingCount
FROM Booking
INNER JOIN Class ON Booking.ClassID = Class.ClassID
WHERE Booking.BookedOn BETWEEN '2026-06-01' AND '2026-06-30'
GROUP BY Class.Coach
HAVING COUNT(*) >= 50
ORDER BY BookingCount DESC;

ပြည့်စုံတဲ့ အဖြေမှာ ပါရမယ့် အရာများ:

  • မှန်ကန်တဲ့ join condition နဲ့ join။
  • WHERE ထဲက ရက်စွဲ အပိုင်းအခြား။
  • GROUP BY Class.Coach။
  • COUNT(*) နဲ့ HAVING COUNT(*) >= 50။
  • ORDER BY BookingCount DESC။

ဥပမာ 5 (HL): Aggregate function အမျိုးမျိုး

2026 ဇွန်လ booking တွေအကြောင်း အနှစ်ချုပ် ကိန်းဂဏန်းတွေကို တွက်ပါ: booking စုစုပေါင်း အရေအတွက်၊ တစ်ရက်ကို ပျမ်းမျှ booking အရေအတွက် (booking ရှိခဲ့တဲ့ ရက်တွေမှာ)၊ အစောဆုံးနဲ့ အနောက်ဆုံး booking ရက်စွဲတွေ။

Booking မှာ booking တစ်ခုကို row တစ်ခု ရှိပြီး ရက်တစ်ရက်ချင်းစီရဲ့ အရေအတွက် မရှိပါဘူး။ ဒါကြောင့် query က ရက်တစ်ရက်ချင်းစီရဲ့ booking တွေကို subquery (query တစ်ခုထဲမှာ ထည့်ရေးထားတဲ့ query၊ FROM ထဲမှာ သုံးရင် နာမည် ပေးရပါတယ်၊ ဒီမှာ PerDay) ထဲမှာ အရင် ရေတွက်ပြီး အဲဒီ နေ့စဉ် အရေအတွက်တွေနဲ့ တွက်ပါတယ်:

SELECT SUM(DayCount)  AS TotalBookings,
       AVG(DayCount)  AS AvgPerBookingDay,
       MIN(BookedOn)  AS Earliest,
       MAX(BookedOn)  AS Latest
FROM (SELECT BookedOn, COUNT(*) AS DayCount
      FROM Booking
      WHERE BookedOn BETWEEN '2026-06-01' AND '2026-06-30'
      GROUP BY BookedOn) AS PerDay;

ဇွန်လမှာ booking လုံးဝ မရှိရင် ဒီ query က NULL တန်ဖိုးတွေ ပါတဲ့ row တစ်ခုကို ပြန်ပေးပါတယ်: row မရှိရင် SUM, AVG, MIN နဲ့ MAX မှာ တန်ဖိုး မရှိလို့ပါ။ COUNT(*) ကတော့ ခြွင်းချက်ပါ၊ 0 ကို ပြန်ပေးပါတယ်။

အဲဒီအစား ဇွန်လ 30 ရက်လုံးအတွက် ပျမ်းမျှ လိုချင်ရင် တစ်လလုံးရဲ့ အရေအတွက်ကို 30.0 နဲ့ စားပါ: SELECT COUNT(*) / 30.0 FROM Booking WHERE BookedOn BETWEEN '2026-06-01' AND '2026-06-30';။ 30 လို့ မရေးဘဲ 30.0 လို့ ရေးပါ: SQLite နဲ့ PostgreSQL က ကိန်းပြည့် တစ်ခုကို ကိန်းပြည့် နောက်တစ်ခုနဲ့ စားရင် ရလဒ်ကိုလည်း ကိန်းပြည့်အဖြစ်ပဲ ပေးလို့ 7 / 2 က 3 ရပါတယ်။

Quick Check (အမြန် စစ်ဆေးမေးခွန်း)

Q1. အောက်ပါတွေထဲက ဘယ်ဟာက DDL command လဲ။

Q2. WHERE Surname LIKE '%berg' pattern က ဘယ် string တွေနဲ့ ကိုက်သလဲ။

Q3. Member နဲ့ Booking table နှစ်ခုလုံးမှာ MemberID ဆိုတဲ့ column ရှိပါတယ်။ သူတို့ကို join လုပ်တဲ့ query ထဲမှာ MemberID ကို select လုပ်တဲ့အခါ ဘာလုပ်ရမလဲ။

Q4. GROUP BY က ထုတ်ပေးတဲ့ group တွေကို ဘယ် clause က filter လုပ်သလဲ။

Q5. WHERE BookedOn BETWEEN '2026-06-01' AND '2026-06-30' condition က ဘယ်ရက်စွဲတွေနဲ့ ကိုက်သလဲ။

Q6 (HL). အောက်ပါတွေထဲက ဘယ်ဟာက အဓိက SQL aggregate function ငါးခုထဲမှာ မပါသလဲ။

Trace the Query (query ကို တစ်ဆင့်ချင်း လိုက်ကြည့်ခြင်း)

Query တစ်ခုစီရဲ့ output ကို ကြိုခန့်မှန်းဖို့ အောက်က နမူနာ ဒေတာ အသေးလေးကို သုံးပါ။

Member

MemberID FirstName Surname DateOfBirth Tier
1001 Aroha Kahurangi 2008-03-14 Standard
1002 Marlon Tan 1995-07-22 Premium
1003 Sebastián Quispe 1980-11-02 Standard
1004 Priya Nair 2003-05-30 Premium

Booking

BookingID MemberID ClassID BookedOn
B9001 1001 C401 2026-05-28
B9002 1002 C401 2026-05-28
B9003 1002 C402 2026-05-29
B9004 1004 C403 2026-05-30

Query တစ်ခုစီက ပြန်ပေးတဲ့ တန်ဖိုး တစ်ခုတည်းကို ရိုက်ထည့်ပါ (ဂဏန်း ဒါမှမဟုတ် နာမည်)။ နာမည်ကို table ထဲကအတိုင်း English စာလုံးနဲ့ ရိုက်ပါ။

Queryရလဒ်
SELECT COUNT(*) FROM Member WHERE Tier = 'Premium';
SELECT FirstName FROM Member WHERE Surname LIKE 'K%';
SELECT COUNT(*) FROM Booking WHERE BookedOn = '2026-05-28';
SELECT MemberID FROM Booking WHERE ClassID = 'C402';
SELECT COUNT(DISTINCT BookedOn) FROM Booking WHERE ClassID = 'C401';

Fill in the Blanks (ကွက်လပ် ဖြည့်ခြင်း)

Booking အနည်းဆုံး တစ်ခု ရှိတဲ့ Premium tier အသင်းဝင် တိုင်းရဲ့ ပထမ နာမည်နဲ့ မျိုးရိုး နာမည်ကို မျိုးရိုး နာမည်အလိုက် အက္ခရာစဉ်နဲ့ စီပြီး ပြတဲ့ SQL query ကို ပြည့်စုံအောင် ဖြည့်ပါ။ ကွက်လပ်တွေမှာ SQL keyword (programming language မှာ အထူး အဓိပ္ပာယ်ရှိတဲ့ စကားလုံး) တွေကို English လို ရိုက်ထည့်ပါ။

SELECT Member.FirstName, Member.Surname
FROM Member
INNER  Booking ON Member.MemberID = Booking.MemberID
 Member.Tier = 'Premium'
 Member.MemberID, Member.FirstName, Member.Surname
 Member.Surname ;

Spot the Error (အမှား ရှာခြင်း)

ကျောင်းသား တစ်ယောက်က booking 10 ခုထက် ပိုတဲ့ class တွေကို ရှာဖို့ SQL query တစ်ခု ရေးနေပါတယ်။ Line တစ်ကြောင်း မှားနေပါတယ်။ အမှားပါတဲ့ line ကို ရွေးပါ၊ ပြီးရင် မှန်ကန်တဲ့ ပြင်နည်းကို ရွေးပါ။

1SELECT ClassID, COUNT(*) AS BookingCount 2FROM Booking 3GROUP BY ClassID 4WHERE COUNT(*) > 10 5ORDER BY BookingCount DESC;

Line 4 အတွက် မှန်ကန်တဲ့ ပြင်နည်းကို ရွေးပါ:

Predict the Output (output ကို ကြိုခန့်မှန်းခြင်း)

Trace အပိုင်းက နမူနာ Member table ကို သုံးရင် အောက်က query က ဘာကို ပြန်ပေးမလဲ။

SELECT FirstName FROM Member WHERE Tier = 'Premium';

ကိုက်ညီတဲ့ အသင်းဝင်တွေရဲ့ ပထမ နာမည်တွေကို table ထဲမှာ ပေါ်တဲ့ အစဉ်အတိုင်း comma နဲ့ ခြားပြီး English လို ရိုက်ထည့်ပါ။

Trace အပိုင်းက နမူနာ Booking table ကို သုံးရင် အောက်က query က ဘာကို ပြန်ပေးမလဲ။

SELECT COUNT(*) FROM Booking WHERE BookedOn > '2026-05-28';

ရလဒ်ကို integer (ကိန်းပြည့်) တစ်ခုတည်းအဖြစ် ရိုက်ထည့်ပါ။

Practice Exercises (လေ့ကျင့်ခန်းများ)

မေးခွန်းတိုင်းမှာ ပါတဲ့ [3 marks] လို mark allocation (မေးခွန်း တစ်ခုစီအတွက် ပေးတဲ့ အမှတ်) တွေက IB စာမေးပွဲ ပုံစံအတိုင်း ပေးထားတာပါ။

Core (အခြေခံ အဆင့်)

  1. [Core] SQL: SELECT [3 marks] DDL နဲ့ DML ကွာခြားချက်ကို Outline (အကျဉ်းချုပ် ဖော်ပြပါ)၊ အမျိုးအစား တစ်ခုစီက command နှစ်ခု စီရဲ့ နာမည်ကို ပေးပါ။

  2. [Core] SQL: SELECT [3 marks] 2000 ခုနှစ် ဇန်နဝါရီ 1 ရက် မတိုင်ခင် မွေးတဲ့ အသင်းဝင် တိုင်းရဲ့ ပထမ နာမည်နဲ့ မျိုးရိုး နာမည်ကို မျိုးရိုး နာမည်အလိုက် အက္ခရာစဉ်နဲ့ စီပြီး ပြတဲ့ SQL query ကို Member table ပေါ်မှာ Write (ရေးပါ)။

  3. [Core] SQL: SELECT [3 marks] မျိုးရိုး နာမည် N ဒါမှမဟုတ် T နဲ့ စတဲ့ အသင်းဝင် တိုင်းရဲ့ ပထမ နာမည်၊ မျိုးရိုး နာမည်နဲ့ မွေးနေ့ကို မွေးနေ့အလိုက် အသက် အကြီးဆုံးကနေ စီပြီး ပြတဲ့ SQL query ကို Write လုပ်ပါ။

Extension (တိုးချဲ့ အဆင့်)

  1. [Extension] SQL: SELECT [4 marks] Tier က 'Premium' ဖြစ်တဲ့ အသင်းဝင်တွေ လုပ်ခဲ့တဲ့ booking တိုင်းအတွက် ပထမ နာမည်၊ မျိုးရိုး နာမည်နဲ့ booking ရက်စွဲကို ပြတဲ့ SQL query ကို Construct (ကိုယ်တိုင် တည်ဆောက်ပါ)။

  2. [Extension] SQL: SELECT [4 marks] 2026 မေ 28 ရက်မှာ လုပ်ခဲ့တဲ့ booking တိုင်းအတွက် အသင်းဝင် တစ်ယောက်ချင်းစီရဲ့ ပထမ နာမည်နဲ့ သူတို့ booking လုပ်ခဲ့တဲ့ class ရဲ့ coach ကို ပြတဲ့ SQL query ကို Construct လုပ်ပါ။

  3. [Extension] SQL: SELECT [3 marks] 2026 ဇွန်လအတွက် အချိန်ဇယား သတ်မှတ်ထားတဲ့ class တိုင်းရဲ့ coach တွေကို မထပ်အောင် (distinct) အက္ခရာစဉ်နဲ့ စီပြီး ပြတဲ့ SQL query ကို Write လုပ်ပါ။

Challenge (စိန်ခေါ်မှု အဆင့်၊ HL)

  1. [Challenge] Aggregates (HL) [5 marks] Membership tier (အသင်းဝင် အဆင့်) တစ်ခုစီအတွက် tier နာမည်နဲ့ အဲဒီ tier ထဲက အသင်းဝင်တွေရဲ့ ပျမ်းမျှ အသက် (နှစ်နဲ့) ကို ပြန်ပေးတဲ့ SQL query ကို Construct လုပ်ပါ။ Member.DateOfBirth ကို သုံးပါ၊ YEAR(date) function က ရက်စွဲကနေ ခုနှစ်ကို ထုတ်ပေးတယ်လို့ ယူဆပါ။

  2. [Challenge] Aggregates (HL) [5 marks] 2026 မှာ class 5 ခုထက် ပိုပြီး သင်ပေးခဲ့တဲ့ coach တိုင်းကို သူတို့ သင်ပေးခဲ့တဲ့ class အရေအတွက်အလိုက် အများဆုံးကနေ စီပြီး ပြတဲ့ SQL query ကို Construct လုပ်ပါ။

  3. [Challenge] Aggregates (HL) [6 marks] Class title (class ခေါင်းစဉ်) တစ်ခုစီအတွက် 2026 ဇွန်လမှာ လုပ်ခဲ့တဲ့ confirmed (အတည်ပြုပြီး) booking (Status = 'confirmed') စုစုပေါင်း အရေအတွက်ကို ပြတဲ့ SQL query ကို Construct လုပ်ပါ။ အဲဒီလို booking အနည်းဆုံး 10 ခု ရှိတဲ့ class တွေကိုပဲ ထည့်ပြီး booking အရေအတွက်အလိုက် ကြီးရာကနေ ငယ်ရာ စီပါ။

Exam-Style (စာမေးပွဲ ပုံစံ မေးခွန်း)

  1. [Exam-Style] SQL: SELECT [2 marks] အပေါ်က နမူနာ table တွေကို သုံးပြီး အောက်က query ရဲ့ output ကို state (ဖော်ပြပါ): SELECT COUNT(DISTINCT MemberID) FROM Booking;

IB CS ကို လေ့လာသူတွေအတွက် မှတ်ချက်: A3.3.2 က SQL query တွေကို construct လုပ်ခိုင်းပါတယ်: query ကို စကားလုံးနဲ့ ဖော်ပြတာ မဟုတ်ဘဲ SQL ကို ကိုယ်တိုင် ရေးရပါတယ်။ A3.3.3 (INSERT, UPDATE နဲ့ DELETE) နဲ့ A3.3.4 (aggregate function များ၊ HL) ကလည်း SQL ကို ရေးခိုင်းပါတယ်၊ ဒါကြောင့် ဒီစာမျက်နှာက query တစ်ခုချင်းစီကို အဖြေ မစစ်ခင် ကိုယ်တိုင် ရေးကြည့်ပြီး လေ့ကျင့်ပါ။

ဆက်စပ် ခေါင်းစဉ်များ

  • အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: Normalisation။ SQL query တွေက 3NF schema ပေါ်မှာ အလုပ်လုပ်ပါတယ်။ JOIN clause တွေက normalisation လုပ်စဉ် ဖန်တီးခဲ့တဲ့ foreign key ချိတ်ဆက်မှုတွေအတိုင်း လိုက်ပါတယ်။
  • ဆက်စပ် ခေါင်းစဉ်: Data Types and Keys။ Column ရဲ့ data type (ဒေတာ အမျိုးအစား) က ဘယ် SQL operator နဲ့ ဘယ် pattern match တွေက အဓိပ္ပာယ် ရှိလဲ ဆိုတာကို ဆုံးဖြတ်ပါတယ်။
  • ဆက်စပ် ခေါင်းစဉ်: Entity-Relationship Diagrams။ JOIN တစ်ခုက ERD (entity တွေနဲ့ ဆက်နွယ်မှုတွေကို ပြတဲ့ ပုံ) ပေါ်က ဆက်နွယ်မှု မျဉ်း တစ်ကြောင်းကို လိုက်တာပါ။
  • နောက်ထပ် လေ့လာမယ့် ခေါင်းစဉ်: SQL Updates။ ဒေတာကို ပြောင်းတဲ့ DML command INSERT INTO, UPDATE SET နဲ့ DELETE။
  • ဆက်လေ့လာရန် (HL): Transactions and Views။ Transaction တွေက SQL statement အများကို “အကုန်ဖြစ် ဒါမှမဟုတ် ဘာမှမဖြစ်” ဆိုတဲ့ အစု တစ်ခုအဖြစ် စုပေးပါတယ်။ View (SELECT query ကို နာမည်ပေးပြီး သိမ်းထားတဲ့ အရာ) တွေက ရှုပ်ထွေးတဲ့ SELECT query တွေကို နာမည်ပေးထားပြီး ပြန်သုံးလို့ရတဲ့ အရာတွေအဖြစ် ထုပ်ပိုးပေးပါတယ်။

© EduCS.me. ကွန်ပျူတာသိပ္ပံ ပညာရေးအတွက် အရင်းအမြစ်တွေ စုထားတဲ့ နေရာပါ။ EduCS is an independent educational resource. It is not affiliated with, or endorsed by, the International Baccalaureate Organization. (EduCS ဟာ သီးခြား ပညာရေး အရင်းအမြစ်တစ်ခုပါ။ International Baccalaureate Organization နဲ့ ဆက်စပ်မှု မရှိသလို သူတို့ရဲ့ ထောက်ခံချက်လည်း မရှိပါဘူး။) ဆက်သွယ်ရန်

Just the Docs နဲ့ တည်ဆောက်ထားပါတယ်။