SQL Cheat Sheet ពាក្យបញ្ជា SQL ដែលអ្នកត្រូវប្រើរាល់ថ្ងៃ

ខ្ញុំចាំថា ពេលរៀន SQL ដំបូង ខ្ញុំមិនដែលចាំបានថា HAVING ខុសពី WHERE ត្រង់ណាទេ។ ធ្វើ Assignment ម្តង បើក Google ម្តង។ សូម្បីតែឥឡូវ ដែលសរសេរ Query ស្ទើររាល់ថ្ងៃ ក៏នៅតែមានពេលខ្លះភ្លេច Syntax ដែរ ជាពិសេសពេលប្តូររវាង SQL Server និង MySQL។

ដូច្នេះខ្ញុំសរសេរ Cheat Sheet នេះទុក ទាំងសម្រាប់ខ្លួនឯង និងសម្រាប់អ្នកដែលកំពុងរៀន។ វាមិនមែនជាមេរៀនពេញលេញទេ។ វាជាទំព័រដែលអ្នកបើកមើលរហ័សពេលកំពុងសរសេរ Query ហើយគាំងមួយភ្លែត។

ល្អបំផុត កុំព្យាយាមទន្ទេញទាំងអស់ក្នុងពេលតែមួយ។ ទុកទំព័រនេះ ហើយបើកមើលពេលត្រូវការ។ ប្រើច្រើនដងទៅ ដៃនឹងចាំខ្លួនឯង។

0. Database គំរូ

ដើម្បីកុំឱ្យឧទាហរណ៍ខ្ចាត់ខ្ចាយ ខ្ញុំប្រើ Database សាលារៀនតូចមួយពេញអត្ថបទ។ វាមាន ៣ Table៖

erDiagram
    STUDENTS ||--o{ ENROLLMENTS : "enrolls in"
    COURSES  ||--o{ ENROLLMENTS : "has"

    STUDENTS {
        int     id PK
        varchar name
        char    gender
        varchar major
        decimal gpa
        date    enrolled_at
    }
    ENROLLMENTS {
        int     student_id FK
        int     course_id  FK
        decimal score
    }
    COURSES {
        int     id PK
        varchar title
        int     credits
    }

• students ផ្ទុកព័ត៌មានសិស្ស
• courses ផ្ទុកមុខវិជ្ជា
• enrollments ប្រាប់ថាសិស្សណារៀនមុខវិជ្ជាណា ហើយបានពិន្ទុប៉ុន្មាន។ Table នេះជាស្ពានភ្ជាប់ Many-to-Many រវាង Table ពីរខាងលើ។

1. SELECT: ទាញយកទិន្នន័យ

ចំណុចចាប់ផ្តើមនៃស្ទើរតែគ្រប់ Query៖

-- យក Column ទាំងអស់
SELECT * FROM students;

-- យកតែ Column ដែលត្រូវការ
SELECT name, major, gpa FROM students;

-- ដាក់ឈ្មោះថ្មីឱ្យ Column (Alias)
SELECT name AS student_name, gpa AS score FROM students;

-- លុបតម្លៃស្ទួនចេញ
SELECT DISTINCT major FROM students;

SELECT * ស្រួលប្រើពេលសាកល្បង ប៉ុន្តែកុំយកវាទៅដាក់ក្នុង Code ពិតប្រាកដ។ វាទាញ Column ដែលអ្នកមិនត្រូវការ ធ្វើឱ្យ Query យឺត ហើយថ្ងៃណាមួយ បើមានគេបន្ថែម Column ថ្មីទៅក្នុង Table នោះ Code របស់អ្នកអាចខូចដោយមិនដឹងខ្លួន។

2. WHERE: ច្រោះយកតែអ្វីដែលចង់បាន

SELECT name, gpa
FROM students
WHERE gpa >= 3.5;

LIKE មាន Wildcard ពីរ៖ % តំណាងឱ្យតួអក្សរប៉ុន្មានក៏បាន (សូម្បីតែគ្មាន) ហើយ _ តំណាងឱ្យតួអក្សរតែមួយ។

SELECT * FROM students WHERE name LIKE 'S%';    -- ចាប់ផ្តើមដោយ S
SELECT * FROM students WHERE name LIKE '%ra';   -- បញ្ចប់ដោយ ra
SELECT * FROM students WHERE name LIKE '_o%';   -- តួអក្សរទី២ ជា o

“

[!IMPORTANT] រឿងមួយដែលស្ទើរតែគ្រប់គ្នាធ្លាប់ជាប់៖ WHERE major = NULL នឹងមិនបាន Row ណាមួយទេ ទោះបីក្នុង Table មាន NULL ច្រើនយ៉ាងណាក៏ដោយ។ NULL មិនមែនជាតម្លៃ វាមានន័យថា "មិនដឹង" ហើយយកអ្វីទៅប្រៀបធៀបជាមួយ "មិនដឹង" ក៏នៅតែ "មិនដឹង" ដដែល។ ត្រូវសរសេរ WHERE major IS NULL។

3. ORDER BY និង LIMIT: តម្រៀប និងកំណត់ចំនួន

-- តម្រៀបពី GPA ខ្ពស់ទៅទាប
SELECT name, gpa FROM students ORDER BY gpa DESC;

-- តម្រៀបតាម major ជាមុន បើដូចគ្នា ទើបតម្រៀបតាម name
SELECT name, major FROM students ORDER BY major ASC, name ASC;

ចង់យកតែ ៥ នាក់ដំបូង? នៅត្រង់នេះហើយដែល Database នីមួយៗចាប់ផ្តើមនិយាយភាសាខុសគ្នា៖

-- MySQL / PostgreSQL / SQLite
SELECT name, gpa FROM students ORDER BY gpa DESC LIMIT 5;

-- SQL Server
SELECT TOP 5 name, gpa FROM students ORDER BY gpa DESC;

ចំពោះ Pagination ឧទាហរណ៍ទំព័រទី ៣ ដែលមួយទំព័របង្ហាញ ១០ Row៖

-- MySQL / PostgreSQL
SELECT * FROM students ORDER BY id LIMIT 10 OFFSET 20;

-- SQL Server (2012 ឡើងទៅ)
SELECT * FROM students ORDER BY id
OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY;

លេខ 20 បានមកពី (page - 1) * page_size ពោលគឺ (3 - 1) * 10។

4. Aggregate Functions: គណនាសរុប

SELECT
    COUNT(*)  AS total_students,
    AVG(gpa)  AS average_gpa,
    MAX(gpa)  AS highest_gpa,
    MIN(gpa)  AS lowest_gpa
FROM students;

ចំណាំបន្តិច៖ COUNT(*) និង COUNT(major) អាចឱ្យលទ្ធផលខុសគ្នា បើសិស្សខ្លះមិនទាន់មាន major។

5. GROUP BY និង HAVING: ដាក់ជាក្រុម

ពេលអ្នកចង់ដឹងលេខសរុប "តាមនីមួយៗ" ដូចជា ចំនួនសិស្សតាមជំនាញនីមួយៗ នោះហើយជាពេលប្រើ GROUP BY។

SELECT major, COUNT(*) AS total, AVG(gpa) AS avg_gpa
FROM students
GROUP BY major;

បើចង់យកតែជំនាញណាដែលមានសិស្សលើសពី ១០ នាក់ យើងប្រើ HAVING៖

SELECT major, COUNT(*) AS total
FROM students
GROUP BY major
HAVING COUNT(*) > 10;

ចុះហេតុអ្វីមិនប្រើ WHERE? វិធីចាំងាយបំផុតដែលខ្ញុំរកឃើញគឺ៖ WHERE ច្រោះ Row នីមួយៗ មុនពេលដាក់ជាក្រុម ចំណែក HAVING ច្រោះ ក្រុម ក្រោយពេលដាក់រួច។ បើលក្ខខណ្ឌរបស់អ្នកមាន COUNT, AVG ឬ Aggregate ផ្សេងទៀត ប្រើ HAVING។ បើគ្មាន ប្រើ WHERE។

ពេលខ្លះត្រូវការទាំងពីរ៖

SELECT major, AVG(gpa) AS avg_gpa
FROM students
WHERE enrolled_at >= '2024-01-01'   -- ច្រោះ Row មុន
GROUP BY major
HAVING AVG(gpa) >= 3.0;             -- ច្រោះក្រុមក្រោយ

“

[!WARNING] Column ណាដែលនៅក្នុង SELECT ហើយមិនមែនជា Aggregate ត្រូវតែមាននៅក្នុង GROUP BY ដែរ។ SQL Server និង PostgreSQL នឹងបោះ Error ភ្លាម។ MySQL ខ្លះអនុញ្ញាត ប៉ុន្តែលទ្ធផលដែលចេញមកអាចខុសដោយមិនដឹងខ្លួន ដែលនោះគួរឱ្យខ្លាចជាង។

6. JOIN: ភ្ជាប់ Table ចូលគ្នា

ផ្នែកនេះជាកន្លែងដែលខ្ញុំឃើញសិស្សច្រឡំច្រើនជាងគេ។ រូបខាងក្រោមជួយបានច្រើន។ A គឺ Table ខាងឆ្វេង B គឺ Table ខាងស្តាំ ហើយផ្ទៃពណ៌ខៀវគឺ Row ដែលនឹងចេញមកក្នុងលទ្ធផល៖

SQL JOIN Types: INNER, LEFT, RIGHT, FULL OUTER

INNER JOIN

បង្ហាញឈ្មោះសិស្ស មុខវិជ្ជា និងពិន្ទុ ដោយភ្ជាប់ Table ទាំងបី៖

SELECT s.name, c.title, e.score
FROM enrollments e
INNER JOIN students s ON e.student_id = s.id
INNER JOIN courses  c ON e.course_id  = c.id;

LEFT JOIN

បង្ហាញសិស្សទាំងអស់ រួមទាំងអ្នកដែលមិនទាន់ចុះឈ្មោះរៀនមុខវិជ្ជាណាមួយផង៖

SELECT s.name, e.course_id
FROM students s
LEFT JOIN enrollments e ON s.id = e.student_id;

ល្បិចមួយដែលប្រើញឹកញាប់

រកសិស្សដែលមិនទាន់ចុះឈ្មោះរៀនអ្វីសោះ។ គំនិតគឺ៖ LEFT JOIN រួចយកតែ Row ដែលខាងស្តាំជា NULL។

SELECT s.name
FROM students s
LEFT JOIN enrollments e ON s.id = e.student_id
WHERE e.student_id IS NULL;

ចំណុចតូចៗដែលគួរដឹង៖

• សរសេរត្រឹមតែ JOIN គឺដូចគ្នានឹង INNER JOIN
• MySQL មិនមាន FULL OUTER JOIN ទេ។ ត្រូវយក LEFT JOIN និង RIGHT JOIN មក UNION គ្នាជំនួស
• ដាក់ Alias ខ្លីៗដូចជា s, c, e ទៅ Query នឹងស្រួលអានជាងមុនច្រើន

7. INSERT, UPDATE, DELETE: កែប្រែទិន្នន័យ

-- បញ្ចូល Row មួយ
INSERT INTO students (name, gender, major, gpa)
VALUES ('Sokha', 'F', 'IT', 3.8);

-- បញ្ចូលច្រើន Row ក្នុងពេលតែមួយ
INSERT INTO students (name, gender, major, gpa)
VALUES
    ('Dara',  'M', 'Math', 3.2),
    ('Chenda','F', 'IT',   3.6);

-- កែប្រែ
UPDATE students
SET gpa = 3.9, major = 'Data Science'
WHERE id = 5;

-- លុប
DELETE FROM students
WHERE id = 5;

“

[!CAUTION] DELETE FROM students; ដោយគ្មាន WHERE នឹងលុបសិស្សទាំងអស់ក្នុង Table។ គ្មានការសួរបញ្ជាក់ គ្មានប៊ូតុង Undo។ រឿងនេះកើតឡើងពិតៗ សូម្បីតែចំពោះ Developer ដែលមានបទពិសោធន៍ច្រើនឆ្នាំ។

ទម្លាប់ដែលខ្ញុំប្រើរាល់ពេលមុនកែ ឬលុបទិន្នន័យ៖

flowchart TD
    A["សរសេរ SELECT ជាមួយ WHERE ដដែល"] --> B{"Row ដែលចេញមក<br/>ត្រឹមត្រូវទេ?"}
    B -- "មិនត្រឹមត្រូវ" --> C["កែ WHERE"]
    C --> A
    B -- "ត្រឹមត្រូវ" --> D["BEGIN TRANSACTION"]
    D --> E["ប្តូរ SELECT ទៅជា UPDATE / DELETE"]
    E --> F{"ចំនួន Row ដែលប៉ះពាល់<br/>ដូចការរំពឹងទុកទេ?"}
    F -- "ដូច" --> G["COMMIT"]
    F -- "មិនដូច" --> H["ROLLBACK"]
    H --> C

នៅក្នុង Code វាមើលទៅដូចនេះ៖

BEGIN TRANSACTION;
DELETE FROM students WHERE gpa < 1.0;
-- ពិនិត្យចំនួន Row ដែលបានលុប...
COMMIT;      -- បើត្រឹមត្រូវ
-- ROLLBACK; -- បើខុស

8. CREATE TABLE និង Constraints

CREATE TABLE courses (
    id       INT PRIMARY KEY,
    title    VARCHAR(100) NOT NULL UNIQUE,
    credits  INT NOT NULL CHECK (credits > 0)
);

CREATE TABLE enrollments (
    student_id INT NOT NULL,
    course_id  INT NOT NULL,
    score      DECIMAL(5,2) DEFAULT 0,
    PRIMARY KEY (student_id, course_id),
    FOREIGN KEY (student_id) REFERENCES students(id),
    FOREIGN KEY (course_id)  REFERENCES courses(id)
);

ID ដែលកើនឡើងដោយខ្លួនឯង (Auto-increment) ក៏សរសេរខុសគ្នាដែរ៖

id INT IDENTITY(1,1) PRIMARY KEY      -- SQL Server
id INT AUTO_INCREMENT PRIMARY KEY     -- MySQL
id SERIAL PRIMARY KEY                 -- PostgreSQL

កែប្រែ ឬលុប Table៖

ALTER TABLE students ADD phone VARCHAR(20);   -- បន្ថែម Column
DROP TABLE enrollments;                       -- លុប Table ទាំងមូល ប្រើដោយប្រុងប្រយ័ត្ន

9. Subquery និង CTE

Subquery គឺ Query មួយដែលនៅក្នុង Query មួយទៀត។ ឧទាហរណ៍ រកសិស្សដែល GPA ខ្ពស់ជាងមធ្យមភាគ៖

SELECT name, gpa
FROM students
WHERE gpa > (SELECT AVG(gpa) FROM students);

បើ Subquery ចាប់ផ្តើមជាន់គ្នាពីរបីជាន់ វាពិបាកអានណាស់។ ពេលនោះ ខ្ញុំប្តូរទៅប្រើ CTE (Common Table Expression) វិញ ព្រោះវាអនុញ្ញាតឱ្យដាក់ឈ្មោះលទ្ធផលមួយផ្នែក ហើយអានពីលើចុះក្រោមដូចអានរឿង៖

WITH course_avg AS (
    SELECT course_id, AVG(score) AS avg_score
    FROM enrollments
    GROUP BY course_id
)
SELECT c.title, ca.avg_score
FROM course_avg ca
JOIN courses c ON c.id = ca.course_id
WHERE ca.avg_score < 60;

Query ខាងលើរកមុខវិជ្ជាណាដែលពិន្ទុមធ្យមទាបជាង ៦០។

10. Window Functions

ផ្នែកនេះលើសពីកម្រិតដំបូងបន្តិច ប៉ុន្តែគេសួរញឹកញាប់ណាស់ក្នុង Interview។

Window Function គណនាលើក្រុម Row ដូច GROUP BY ដែរ ប៉ុន្តែមិនបង្រួម Row ទាំងនោះទៅជាមួយទេ។ Row នីមួយៗនៅតែមាន ហើយទទួលបានលទ្ធផលគណនាមកជាប់ខ្លួន។

-- ចាត់ថ្នាក់សិស្សតាម GPA ក្នុងជំនាញនីមួយៗ
SELECT
    name,
    major,
    gpa,
    RANK() OVER (PARTITION BY major ORDER BY gpa DESC) AS rank_in_major
FROM students;

Function ចាត់ថ្នាក់ទាំងបីខុសគ្នាតែពេលមានពិន្ទុស្មើគ្នា។ ឧទាហរណ៍ពិន្ទុ 95, 95, 90៖

សំណួរ Interview មួយដែលខ្ញុំជួបញឹកញាប់៖ "យកសិស្សពូកែជាងគេម្នាក់ក្នុងជំនាញនីមួយៗ"។ ចម្លើយគឺ៖

WITH ranked AS (
    SELECT name, major, gpa,
           ROW_NUMBER() OVER (PARTITION BY major ORDER BY gpa DESC) AS rn
    FROM students
)
SELECT name, major, gpa FROM ranked WHERE rn = 1;

11. SQL ដំណើរការតាមលំដាប់ណា?

យើងសរសេរ SELECT នៅខាងលើគេ ប៉ុន្តែតាមពិត Database ដំណើរការវាស្ទើរតែចុងក្រោយ។ ពេលខ្ញុំយល់ចំណុចនេះ Error ជាច្រើនដែលធ្លាប់ធ្វើឱ្យខ្ញុំងឿងឆ្ងល់ ស្រាប់តែសមហេតុផលភ្លាម។

flowchart TD
    A["1. FROM / JOIN<br/>យក Table និងភ្ជាប់គ្នា"] --> B["2. WHERE<br/>ច្រោះ Row"]
    B --> C["3. GROUP BY<br/>ដាក់ជាក្រុម"]
    C --> D["4. HAVING<br/>ច្រោះក្រុម"]
    D --> E["5. SELECT<br/>ជ្រើស Column, គណនា, បង្កើត Alias"]
    E --> F["6. DISTINCT<br/>លុបតម្លៃស្ទួន"]
    F --> G["7. ORDER BY<br/>តម្រៀប"]
    G --> H["8. LIMIT / TOP<br/>កំណត់ចំនួន"]

    style A fill:#dbeafe,stroke:#1d4ed8
    style B fill:#dbeafe,stroke:#1d4ed8
    style C fill:#fef3c7,stroke:#b45309
    style D fill:#fef3c7,stroke:#b45309
    style E fill:#dcfce7,stroke:#15803d
    style F fill:#dcfce7,stroke:#15803d
    style G fill:#f3e8ff,stroke:#7e22ce
    style H fill:#f3e8ff,stroke:#7e22ce

ឧទាហរណ៍ជាក់ស្តែង៖ ហេតុអ្វីបានជា WHERE avg_gpa > 3 បោះ Error ថារក Column avg_gpa មិនឃើញ? ព្រោះ WHERE ស្ថិតនៅជំហានទី ២ ខណៈដែល Alias avg_gpa ទើបតែកើតនៅជំហានទី ៥។ នៅពេល WHERE ដំណើរការ ឈ្មោះនោះមិនទាន់មានទេ។ ផ្ទុយទៅវិញ ORDER BY avg_gpa ដំណើរការធម្មតា ព្រោះវានៅក្រោយ SELECT។

12. Database នីមួយៗខុសគ្នាត្រង់ណា?

គន្លឹះតូចមួយ៖ COALESCE() ប្រើបានគ្រប់ Database ទាំងបី។ បើអ្នកមិនប្រាកដថាថ្ងៃក្រោយនឹងប្តូរ Database ឬអត់ ប្រើវាជំនួស ISNULL() ឬ IFNULL() ទៅ។

13. កំហុសដែលខ្ញុំឃើញញឹកញាប់

ចំណុចចុងក្រោយនោះសំខាន់ជាងគេ។ ពេលអ្នកចាប់ផ្តើមភ្ជាប់ SQL ជាមួយ Website ឬ App ពិតប្រាកដ សូមកុំយកអ្វីដែល User វាយបញ្ចូលទៅតភ្ជាប់ជា String ក្នុង Query ដោយផ្ទាល់ឱ្យសោះ។

លំហាត់សាកល្បង

អានហើយ សាកសរសេរខ្លួនឯងម្តង។ ប្រើ Database គំរូខាងលើ៖

1. បង្ហាញសិស្សជំនាញ IT ដែលមាន GPA ចាប់ពី 3.0 ឡើង តម្រៀបពីខ្ពស់ទៅទាប
2. រាប់ចំនួនសិស្សប្រុស និងស្រីក្នុងជំនាញនីមួយៗ
3. រកមុខវិជ្ជាដែលមិនទាន់មានសិស្សចុះឈ្មោះសោះ
4. បង្ហាញសិស្ស ៣ នាក់ដែលមានពិន្ទុមធ្យមខ្ពស់ជាងគេ គិតលើគ្រប់មុខវិជ្ជា
5. ចាត់ថ្នាក់សិស្សតាមពិន្ទុក្នុងមុខវិជ្ជានីមួយៗដោយប្រើ DENSE_RANK()

មិនចាំបាច់ Install អ្វីទេ។ អាចសាកលេងលើ DB Fiddle, SQLFiddle ឬ SQLite Online បានភ្លាមៗពី Browser។

និយាយចុងក្រោយ

ការងារ SQL ភាគច្រើនប្រចាំថ្ងៃ ពិតជាប្រើតែ SELECT, WHERE, JOIN, GROUP BY និង ORDER BY ប៉ុណ្ណោះ។ ស្ទាត់ ៥ យ៉ាងនេះសិន ចាំបន្តទៅ CTE និង Window Function ពេលក្រោយក៏មិនយឺតដែរ។

ហើយកុំបារម្ភបើអ្នកនៅតែត្រូវបើកមើល Cheat Sheet នេះញឹកញាប់។ ខ្ញុំក៏នៅតែបើកមើលដែរ។