ហេតុអ្វីបានជា Database និង Relational Model

មាតិកា

1. បញ្ហា៖ ទិន្នន័យដែលធំជាងឯកសារ
2. Spreadsheet ទល់នឹង Database Table
3. Table, Row និង Column
4. គំនិត Relational៖ Table ដែលចង្អុលគ្នាទៅវិញទៅមក
5. SQL៖ ប្រាប់អ្វីដែលអ្នកចង់បាន មិនមែនរបៀបទទួលបានវាទេ
6. ប្រភេទបីនៃ SQL Statement
7. អ្វីទៅជា PostgreSQL៖ Client និង Server
8. Database ផ្សេងទៀតដែលអ្នកនឹងជួប
9. ផែនការ៖ shopdb
10. សាកល្បងដោយខ្លួនឯង

1. បញ្ហា៖ ទិន្នន័យដែលធំជាងឯកសារ

ស្រមៃថាអ្នកចាប់ផ្តើមហាងអនឡាញតូចមួយ។ នៅថ្ងៃដំបូង អ្នករក្សាទុកការបញ្ជាទិញក្នុងឯកសារអក្សរមួយ៖

2026-01-05, Sokha Chan, Wireless Mouse, 1, 15.00
2026-01-05, Sokha Chan, USB-C Cable, 2, 5.50
2026-01-20, Sokha Chan, Mechanical Keyboard, 1, 79.00

វាដំណើរការសម្រាប់ការបញ្ជាទិញដប់។ ពេលអ្នកមានដប់ពាន់ សំណួរចាប់ផ្តើមកើតឡើង៖

• តើ Sokha បានចំណាយសរុបប៉ុន្មាន? អ្នកត្រូវអានគ្រប់បន្ទាត់។
• Sokha ប្តូរឈ្មោះក្រោយរៀបការ។ អ្នកត្រូវរក និងកែគ្រប់បន្ទាត់ដែលនាងលេចឡើង ហើយប្រសិនបើអ្នករំលងមួយ ទិន្នន័យរបស់អ្នកនឹងមិនស៊ីសង្វាក់គ្នាខ្លួនឯង។
• បុគ្គលិកពីរនាក់បន្ថែមការបញ្ជាទិញក្នុងពេលតែមួយ។ ម្នាក់សរសេរជាន់លើការផ្លាស់ប្តូររបស់ម្នាក់ទៀត ឬឯកសារខូចពាក់កណ្តាលពេលសរសេរ។
• មានអ្នកវាយ Wirelss Mouse។ គ្មានអ្វីរារាំងពួកគេទេ។
• កុំព្យូទ័រគាំងពេលកំពុងរក្សាទុក។ តើឯកសារនៅក្នុងស្ថានភាពល្អឬទេ? គ្មានអ្នកណាដឹងទេ។

អ្នកអាចដោះស្រាយបញ្ហានីមួយៗដោយសរសេរកូដ៖ parser, ជំនួយការស្វែងរក, ការចាក់សោ (locking), validation, backup។ ការធ្វើបែបនោះសម្រាប់គ្រប់ project គឺយឺត ហើយអ្នកនឹងសាងសង់យន្តការដដែលម្តងហើយម្តងទៀត។

Database គឺជាយន្តការនោះ ដែលបានសាងសង់រួច សាកល្បងរួច និងលឿន។ វារក្សាទុកទិន្នន័យតាមរបៀបមានរចនាសម្ព័ន្ធ អនុញ្ញាតឲ្យអ្នកប្រើច្រើននាក់អាន និងសរសេរក្នុងពេលតែមួយ ពិនិត្យទិន្នន័យតាមច្បាប់ ស៊ូទ្រាំនឹងការគាំង និងឆ្លើយសំណួរបានលឿន សូម្បីតែមានកំណត់ត្រារាប់លាន។

សរុបមក database ផ្តល់ឲ្យអ្នកនូវប្រាំយ៉ាងដែលឯកសារធម្មតាមិនមាន៖

2. Spreadsheet ទល់នឹង Database Table

Database ដំបូងរបស់មនុស្សជាច្រើនគឺ spreadsheet ហើយ spreadsheet ល្អណាស់។ សម្រាប់ថវិកាផ្ទាល់ខ្លួន ឬការគណនាលឿនៗ សូមប្រើវា។ ប៉ុន្តែមើលអ្វីដែលកើតឡើង នៅពេលអ្នកតាមដានការបញ្ជាទិញក្នុង sheet តែមួយ៖

ឈ្មោះ និងអ៊ីមែលរបស់ Sokha ត្រូវបានធ្វើឡើងវិញនៅគ្រប់ row។ ប្រសិនបើអ៊ីមែលរបស់នាងប្តូរ អ្នកត្រូវកែបី row (ឬបីរយ)។ Sheet មិនរារាំងអ្នកពីការវាយ sokha@exmple.com នៅក្នុងមួយក្នុងចំណោមនោះទេ។ តម្លៃរបស់ mouse ត្រូវបានរក្សាទុកក្នុងគ្រប់ការបញ្ជាទិញ ហើយគ្មានអ្វីប្រាប់ថា row ពីរសម្រាប់ផលិតផលតែមួយត្រូវតែត្រូវគ្នាទេ។ ហើយ sheet គ្មានវិធីនិយាយថា "qty ត្រូវតែជាចំនួនគត់វិជ្ជមាន" ដែលមនុស្សម្នាក់ដែលតាំងចិត្តមិនអាចបិទបាំងដោយការ paste ជាន់ពីលើបានទេ។

Database table មើលទៅដូច sheet មួយច្រើន ប៉ុន្តែវាមានភាពខុសគ្នាធំបី៖

1. គ្រប់ column មាន type និងច្បាប់។ Column ដែលប្រកាសជាចំនួនគត់នឹងបដិសេធអក្សរ abc។ Column អាចតម្រូវឲ្យមាន, មានតែមួយគត់ (unique) ឬកំណត់ក្នុងចន្លោះមួយ។
2. Table ត្រូវបានញែកដាច់ពីគ្នា ហើយតភ្ជាប់គ្នា។ ជំនួសឲ្យការធ្វើឡើងវិញនូវព័ត៌មានរបស់ Sokha នៅគ្រប់ row នៃការបញ្ជាទិញ អ្នករក្សាទុកនាងម្តងក្នុង table customers ហើយឲ្យការបញ្ជាទិញនីមួយៗចង្អុលទៅនាង។
3. អ្នក query មិនមែនរមូរទេ។ អ្នកមិនត្រូវ filter និងចម្លង cell ដោយដៃទេ។ អ្នកសរសេរសំណួរ ហើយ database រកចម្លើយ សូម្បីក្នុង row រាប់លាន។

ចំណុចទីពីរគឺជាបេះដូងនៃស៊េរីទាំងមូលនេះ ដូច្នេះសូមមើលវាឲ្យជិត។

3. Table, Row និង Column

Relational database រក្សាទុកទិន្នន័យក្នុង table។ Table មាន៖

• Column (ហៅផងដែរថា field ឬ attribute)៖ ព័ត៌មានដែលមានឈ្មោះ និងមាន type ដូចជា name ឬ email។
• Row (ហៅផងដែរថា record ឬ tuple)៖ ធាតុមួយក្នុងមួយ row ដូចជាអតិថិជនម្នាក់។

នេះគឺជា table customers តូចមួយ៖

Table នេះមានបួន column និងបី row។ ចំណុចខ្លះដែលត្រូវកត់សម្គាល់៖

• Row នីមួយៗមាន id ជាលេខដែលកំណត់អត្តសញ្ញាណអតិថិជននោះ ហើយគ្មានអ្នកផ្សេងទេ។ ឈ្មោះអាចស្ទួនគ្នា (មនុស្សពីរនាក់អាចមានឈ្មោះ Dara Kim) ប៉ុន្តែ id មិនដែលស្ទួនទេ។ Column ដែលកំណត់អត្តសញ្ញាណនេះហៅថា primary key។ យើងសិក្សាអំពី key ក្នុង ជំពូកទី 6។
• តម្លៃទាំងអស់ក្នុង column តែមួយមាន type ដូចគ្នា។ អ្នកនឹងមិនឃើញលេខក្នុង name ឬឈ្មោះក្នុង id ទេ។
• លំដាប់នៃ row មិនមែនជាផ្នែកនៃ table ទេ។ Database មិនសន្យាថាផ្តល់ row ត្រឡប់មកតាមលំដាប់ដែលអ្នក insert ទេ លុះត្រាតែអ្នកសុំលំដាប់ជាក់លាក់។

ពាក្យមួយចំនួនដែលអ្នកនឹងឮម្តងហើយម្តងទៀត៖

Schema គួរចងចាំ។ វាគឺជាប្លង់នៃ database របស់អ្នក។ ទិន្នន័យផ្លាស់ប្តូរគ្រប់នាទី ប៉ុន្តែ schema ផ្លាស់ប្តូរកម្រណាស់ និងដោយប្រុងប្រយ័ត្ន។

4. គំនិត Relational៖ Table ដែលចង្អុលគ្នាទៅវិញទៅមក

ពាក្យ "relational" មិនមែនមានន័យថា table "ទាក់ទង" នឹងមិត្តភក្តិទេ។ វាមកពីសាខាមួយនៃគណិតវិទ្យា (relation ដែលជាសំណុំនៃ row) ដែល Edgar Codd នៅ IBM បានប្រើក្នុងឆ្នាំ 1970។ គំនិតជាក់ស្តែងសាមញ្ញជាងនេះច្រើន៖

រក្សាទុកការពិតនីមួយៗក្នុងកន្លែងតែមួយ ហើយតភ្ជាប់ table ដោយប្រើតម្លៃរួម។

តោះជួសជុល spreadsheet ពីផ្នែកទី 2។ បំបែកវាជាបី table។ ទីមួយ អតិថិជន (មនុស្សម្នាក់ៗម្តង)៖

ទីពីរ ផលិតផល (ផលិតផលនីមួយៗម្តង ជាមួយតម្លៃរបស់វា)៖

ទីបី បន្ទាត់នៃការបញ្ជាទិញ ដែលមានតែលេខដែលចង្អុលទៅ table ពីរផ្សេងទៀត៖

អានបន្ទាត់ដំបូងនៃ table ចុងក្រោយ៖ អតិថិជន 1 បានទិញផលិតផល 1 ចំនួន 1។ ដើម្បីមើលឈ្មោះ database join table ទាំងនោះ៖ វាតាម customer_id ទៅ row ក្នុង customers ដែលមាន id នោះ ហើយតាម product_id ទៅ row ដែលត្រូវគ្នាក្នុង products។ Column ដែលផ្ទុក key របស់ table ផ្សេងត្រូវបានហៅថា foreign key។

ឥឡូវមើលអ្វីដែលយើងទទួលបាន៖

• អ៊ីមែលរបស់ Sokha នៅក្នុង row តែមួយប៉ុណ្ណោះ។ ប្តូរម្តង ហើយគ្រប់ការបញ្ជាទិញនឹងឃើញតម្លៃថ្មី។
• ការវាយខុសមិនអាចបង្កើតអតិថិជនខ្មោចបានទេ ព្រោះ database អាចបដិសេធ customer_id ដែលមិនមានក្នុង customers។
• តម្លៃ mouse ត្រូវបានរក្សាទុកម្តង។ ប្តូរតម្លៃក្នុង row តែមួយ។
• Table នៅតូច។ លេខចំណាយក្នុងការរក្សាទុកតិចជាងអក្សរដែលធ្វើឡើងវិញ។

នេះគឺជាខ្លឹមសារនៃ relational model៖ table តូចៗដែលផ្តោតលើរឿងមួយ តភ្ជាប់គ្នាដោយ key។ ការ Join គឺជារបៀបដែលអ្នកផ្សំពួកវាត្រឡប់មកវិញ នៅពេលអ្នកសួរសំណួរ។ យើងចំណាយពេលទាំងមូលនៃ ជំពូកទី 7 លើ join។

អ្នកមិនចាំបាច់រៀនគណិតវិទ្យានៅពីក្រោយវាទេ។ អ្នកគ្រាន់តែត្រូវរៀនគិតជា table៖ "តើអ្វីជាវត្ថុនៅក្នុងបញ្ហារបស់ខ្ញុំ? តើការពិតអ្វីខ្លះជារបស់វត្ថុនីមួយៗ? តើវត្ថុណាចង្អុលទៅវត្ថុណា?"

5. SQL៖ ប្រាប់អ្វីដែលអ្នកចង់បាន មិនមែនរបៀបទទួលបានវាទេ

ដើម្បីនិយាយជាមួយ relational database អ្នកប្រើ SQL (Structured Query Language ដែលអានថា "sequel" ឬ "S-Q-L" ទាំងពីរសុទ្ធតែនិយម)។ SQL ជាស្តង់ដារអស់រយៈពេល 50 ឆ្នាំ ហើយការចេះវាអាចយកទៅប្រើបានទាំង database និងការងារផ្សេងៗ។

នេះគឺជាសំណួរជាភាសាអង់គ្លេសធម្មតា៖ "តើផលិតផលណាខ្លះមានតម្លៃលើសពី 20 ដុល្លារ?" ក្នុង SQL៖

SELECT name, price
FROM products
WHERE price > 20;

លទ្ធផលធម្មតា នៅពេល table មានទិន្នន័យរបស់យើង៖

        name         | price
---------------------+-------
 Mechanical Keyboard | 79.00
 SQL Cookbook        | 32.00
 Clean Code          | 28.50
 Desk Lamp           | 22.00

ប្រៀបធៀបនេះជាមួយរបៀបដែលអ្នកធ្វើវាក្នុង JavaScript៖

const result = [];
for (const p of products) {
  if (p.price > 20) {
    result.push({ name: p.name, price: p.price });
  }
}

JavaScript ប្រាប់កុំព្យូទ័រថា របៀប ធ្វើ៖ loop, ពិនិត្យ, push។ SQL ប្រាប់ database ថា អ្វី ដែលអ្នកចង់បាន៖ ឈ្មោះ និងតម្លៃ ពី products ដែលតម្លៃលើសពី 20។ រចនាប័ទ្មនេះហៅថា declarative។ អ្នកពិពណ៌នាលទ្ធផល ហើយ database សម្រេចចិត្តរបៀបរកវា។ វាអាចដើរកាត់ table ទាំងមូល ឬលោតត្រង់ទៅចម្លើយដោយប្រើ index (ជំពូកទី 11)។ អ្នកមិនបារម្ភទេ ហើយសេរីភាពនោះមានអានុភាព។ នៅពេល table មាន row ដប់លាន database ជ្រើសរើសផែនការដែលឆ្លាតជាងនេះ ដោយមិនចាំបាច់ឲ្យអ្នកផ្លាស់ប្តូរ query របស់អ្នកទេ។

SQL អានស្ទើរតែដូចភាសាអង់គ្លេស ដែលធ្វើឲ្យវាងាយចាប់ផ្តើម។ ទម្លាប់តូចៗពីរដែលគួរដឹងឥឡូវនេះ៖

• Statement បញ្ចប់ដោយសញ្ញាចុច-ក្បៀស (;)។
• តាមទម្លាប់ SQL keyword ត្រូវបានសរសេរជាអក្សរធំ (SELECT, FROM) ហើយឈ្មោះជាអក្សរតូច។ SQL មិនតម្រូវទេ ប៉ុន្តែវាធ្វើឲ្យ query អានងាយជាង ហើយយើងអនុវត្តតាមវាពេញមួយស៊េរីនេះ។

6. ប្រភេទបីនៃ SQL Statement

SQL statement ចែកជាក្រុមតិចតួច។ ការដឹងក្រុមប្រាប់អ្នកថា statement មួយអាចធ្វើអ្វីចំពោះទិន្នន័យរបស់អ្នក។

គិតអំពីទូដាក់ឯកសារ។ DDL សាងសង់ទូ និងថតឯកសារ (រចនាសម្ព័ន្ធ)។ DML ដាក់ក្រដាសចូលក្នុងថត កែវា និងដកវាចេញ (មាតិកា)។ DQL មើលអ្វីដែលមាននៅក្នុងនោះ ដោយមិនផ្លាស់ប្តូរអ្វីឡើយ។

ក្រុមទីបួន transaction control (BEGIN, COMMIT, ROLLBACK) ដាក់ការផ្លាស់ប្តូរជាច្រើនជាអង្គតែមួយបែប all-or-nothing។ ក្រុមមួយទៀត គឺ access control (GRANT, REVOKE) សម្រេចថានរណាអាចធ្វើអ្វី។ ទាំងពីរមកក្នុងជំពូកទី 12។

នេះគឺជារបៀបដែលស៊េរីអនុវត្តតាមផែនទីនេះ៖

• ជំពូកទី 3 ភាគច្រើនជា DDL៖ កំណត់ table។
• ជំពូកទី 4 ជា DML៖ បំពេញ និងផ្លាស់ប្តូរពួកវា។
• ជំពូកទី 5 ដល់ 9 ជា DQL៖ សួរសំណួរកាន់តែល្អឡើងៗ។
• ជំពូកទី 10 និង 11 ត្រឡប់ទៅរកការរចនា និងល្បឿន។
• ជំពូកទី 12 គឺអំពីការធ្វើអ្វីៗទាំងអស់នេះដោយសុវត្ថិភាព។

7. អ្វីទៅជា PostgreSQL៖ Client និង Server

SQL គឺជាភាសា។ Database management system (DBMS) គឺជាកម្មវិធីដែលយល់ភាសានោះ រក្សាទុកទិន្នន័យលើថាស និងអនុវត្តច្បាប់។ PostgreSQL (អានថា "post-gress-Q-L" ជារឿយៗគ្រាន់តែ "Postgres") គឺជាប្រព័ន្ធមួយបែបនេះ។ វាឥតគិតថ្លៃ ប្រភពបើកចំហ មានអាយុលើសពី 30 ឆ្នាំ ហើយត្រូវបានជឿទុកចិត្តដោយក្រុមហ៊ុនគ្រប់ទំហំ។ វាក៏ល្បីថាធ្វើតាមស្តង់ដារ SQL យ៉ាងជិតស្និទ្ធ និងគាំទ្រមុខងារកម្រិតខ្ពស់ដូចជា JSON column, full-text search និងភាពសុចរិតនៃទិន្នន័យដ៏រឹងមាំ។

រឿងសំខាន់បំផុតដែលត្រូវយល់គឺរូបរាងរបស់វា។ Postgres គឺជា server។ វាជាកម្មវិធីដែលដំណើរការនៅផ្ទៃខាងក្រោយ ស្តាប់លើ network port (លំនាំដើម 5432) ហើយរង់ចាំ client មកតភ្ជាប់៖

 +-----------+      SQL text       +------------------+     +-------+
 |  Client   | ------------------> |  PostgreSQL      | --> | Files |
 | (psql,    |                     |  server          |     | on    |
 |  Node.js, | <------------------ |  (port 5432)     | <-- | disk  |
 |  GUI app) |      result rows    |                  |     +-------+
 +-----------+                     +------------------+

Client គឺអ្វីក៏ដោយដែលផ្ញើ SQL ហើយអានចម្លើយ៖

• psql ជា client បែប command-line ដែលមកជាមួយ Postgres។ យើងប្រើវាក្នុងស៊េរីនេះ។
• ឧបករណ៍ក្រាហ្វិកដូចជា DBeaver ឬ TablePlus។
• កម្មវិធីផ្ទាល់ខ្លួនរបស់អ្នក៖ កម្មវិធី Node.js, Python ឬ Go ដែលប្រើបណ្ណាល័យ database។

ការញែកដាច់នេះពន្យល់រឿងជាច្រើនដែលអ្នកនឹងឃើញនៅពេលក្រោយ។ វាជាហេតុដែលអ្នកចាប់ផ្តើម server មុន ហើយតភ្ជាប់ក្រោយ។ វាជាហេតុដែល client ច្រើនអាចប្រើ database តែមួយក្នុងពេលតែមួយ។ វាជាហេតុដែលកម្មវិធីគេហទំព័រមិនដែលបើកឯកសារ database ដោយខ្លួនឯង ប៉ុន្តែផ្ញើ SQL តាមរយៈ connection ហើយ connection នោះត្រូវការ username និង password។ ហើយវាជាហេតុដែល SQL injection (ជំពូកទី 12) ជាហានិភ័យយ៉ាងធំ៖ កម្មវិធីរបស់អ្នកសាងសង់ SQL ជាអក្សរ ហើយផ្ញើវាទៅ server។

នៅក្នុង Postgres server តែមួយអាចមាន database ច្រើន ហើយនៅក្នុង database នីមួយៗមាន table។ សម្រាប់ស៊េរីនេះ យើងបង្កើត database តែមួយគឺ shopdb នៅលើ server ដែលដំណើរការក្នុង Docker container។ នោះរក្សាកុំព្យូទ័រអ្នកឲ្យស្អាត៖ ប្រសិនបើអ្នកចង់ចាប់ផ្តើមឡើងវិញ អ្នកលុប container។

8. Database ផ្សេងទៀតដែលអ្នកនឹងជួប

Postgres មិនមែនជា relational database តែមួយគត់ទេ។ អ្វីដែលអ្នករៀននៅទីនេះអាចយកទៅប្រើបាន ព្រោះពួកវាទាំងអស់និយាយ SQL ដោយមានភាពខុសគ្នាតិចតួច ("dialect")។

អ្នកក៏អាចនឹងឮអំពី NoSQL database ដូចជា MongoDB, Redis ឬ DynamoDB។ ពួកវារក្សាទុកទិន្នន័យក្នុងរូបរាងផ្សេងទៀត (document, key-value pair) ហើយដោះដូរមុខងារខ្លះដើម្បីភាពបត់បែន ឬល្បឿន។ ពួកវាជាឧបករណ៍មានប្រយោជន៍ ប៉ុន្តែសម្រាប់កម្មវិធីភាគច្រើនដែលមានទិន្នន័យតភ្ជាប់គ្នាដូចជាអតិថិជន ការបញ្ជាទិញ និងការទូទាត់ relational database គឺជាជម្រើសលំនាំដើមដែលមានសុវត្ថិភាពបំផុត។ ប្រសិនបើអ្នកស្ទាត់ SQL មុន ការរៀន database ផ្សេងទៀតនៅពេលក្រោយនឹងងាយស្រួលជាងច្រើន។

ហេតុអ្វីបានជា Postgres នៅទីនេះ? វាឥតគិតថ្លៃ ដំណើរការគ្រប់ទីកន្លែង តឹងរ៉ឹងចំពោះភាពត្រឹមត្រូវនៃទិន្នន័យ (ជាទម្លាប់ល្អដែលត្រូវរៀនឲ្យឆាប់) ហើយត្រូវបានស្នើសុំយ៉ាងទូលំទូលាយក្នុងការផ្សព្វផ្សាយការងារ។ នៅពេលជំពូកមួយប្រើមុខងារដែលមានតែក្នុង Postgres យើងនឹងប្រាប់។

9. ផែនការ៖ shopdb

អ្នករៀន database ដោយការសាងសង់មួយ។ ក្នុងគ្រប់ជំពូក យើងនឹងបន្ថែមទៅ project តែមួយ៖ database របស់ហាងអនឡាញតូចមួយដែលហៅថា shopdb។

ការរចនាចុងក្រោយមានប្រាំ table៖

 customers          categories
 ---------          ----------
 id                 id
 name               name
 email
 city                  |
 created_at            | one category has many products
   |                   v
   |               products
   |               --------
   |               id
   |               name
   |               price
   |               stock
   |               category_id
   |                   ^
   | one customer      | one product appears in many order lines
   | has many orders   |
   v                   |
 orders            order_items
 ------            -----------
 id                order_id
 customer_id       product_id
 status            quantity
 ordered_at        unit_price

ការទស្សនាខ្លី៖

• customers ផ្ទុកមនុស្សដែលទិញ។
• categories ដាក់ផលិតផលជាក្រុម (Electronics, Books, Home)។
• products គឺជាអ្វីដែលអ្នកលក់ ម្នាក់ៗមានតម្លៃ និងចំនួនស្តុក។
• orders គឺជាការទិញ ម្នាក់ៗជារបស់អតិថិជនម្នាក់។
• order_items គឺជាបញ្ជីបន្ទាត់ក្នុងការបញ្ជាទិញនីមួយៗ៖ ផលិតផលអ្វី ចំនួនប៉ុន្មាន តម្លៃប៉ុន្មាន។

កុំបារម្ភប្រសិនបើដ្យាក្រាមមិនទាន់ច្បាស់។ អ្នកនឹងសាងសង់វា table ម្តងមួយៗ ហើយដល់ជំពូកទី 6 គ្រប់ព្រួញនឹងមានន័យ។

នេះគឺជាផែនការតាមជំពូក៖

ចាប់ពីជំពូកទី 2 អ្នកនឹងរក្សាថតឈ្មោះ shopdb/ ដែលមានឯកសារ .sql ពីរបីនៅក្នុង៖ schema.sql (table), seed.sql (ទិន្នន័យគំរូ) និងថត queries/ ដែលមានសំណួររបស់អ្នកផ្ទាល់។ ឯកសារទាំងនេះគឺជាផលិតផលពិតនៃស៊េរីនេះ។ ដោយសារអ្វីៗទាំងអស់នៅក្នុងឯកសារអក្សរ អ្នកអាចលុប database ហើយសាងសង់វាឡើងវិញក្នុងពីរបីវិនាទីដោយ command តែមួយ។ នោះក៏ជារបៀបដែលក្រុមអ្នកជំនាញធ្វើការដែរ៖ រចនាសម្ព័ន្ធ database គឺជាកូដក្នុង repository មិនមែនជាការចុចដែលគ្មានអ្នកណាចាំទេ។

អ្នកក៏នឹងប្រើសំណុំទិន្នន័យគំរូថេរមួយ។ អតិថិជនប្រាំនាក់ (Sokha, Dara, Linda, Vuthy, Maly) ផលិតផលប្រាំបី និងការបញ្ជាទិញប្រាំ។ គ្រប់ table លទ្ធផលក្នុងស៊េរីនេះត្រូវបានគណនាពីទិន្នន័យនោះ ដូច្នេះប្រសិនបើអ្នកធ្វើតាម លទ្ធផលរបស់អ្នកនឹងត្រូវនឹងអ្វីដែលអ្នកអាន។

10. សាកល្បងដោយខ្លួនឯង

លំហាត់ទាំងនេះត្រូវការតែក្រដាស ឬ text editor ប៉ុណ្ណោះ។ មិនទាន់ត្រូវដំឡើងអ្វីទេ។

1. រកការធ្វើឡើងវិញ។ មើល table នៃវីដេអូបង្រៀននេះ៖

   title	channel	channel_email
   Intro to SQL	Mengsreang Channel	hello@example.com
   Joins Explained	Mengsreang Channel	hello@example.com
   Docker Basics	Mengsreang Channel	hello@example.com

   តើអ្វីត្រូវបានធ្វើឡើងវិញ? តើមានអ្វីខុសប្រសិនបើអ៊ីមែលប្តូរ? គូរសង្ខេបថាតើអ្នកនឹងបំបែកវាជា table ពីរយ៉ាងដូចម្តេច និង column ណាតភ្ជាប់ពួកវា។

2. គូរ table ផ្ទាល់ខ្លួនរបស់អ្នក។ ជ្រើសរើសអ្វីដែលអ្នកស្គាល់ច្បាស់ ដូចជាបណ្ណាល័យ សាលារៀន ឬកម្មវិធីដឹកអាហារ។ រាយបី table ដែលមានបួនឬប្រាំ column ក្នុងមួយ table។ សម្រាប់ table នីមួយៗ គូសរង្វង់ជុំវិញ column ដែលកំណត់អត្តសញ្ញាណ row ហើយគូរព្រួញពី column ណាដែលយោងទៅ table ផ្សេង។

3. Declarative ទល់នឹង imperative។ សរសេរ loop ក្នុង JavaScript ដែលរកអតិថិជនទាំងអស់នៅ Phnom Penh ពីបញ្ជី object។ បន្ទាប់មកសរសេរអ្វីដែលអ្នកគិតថា SQL មើលទៅដូចក្នុងទម្រង់ SELECT ... FROM ... WHERE ...។ មួយណាខ្លីជាង? មួយណាប្រាប់កុំព្យូទ័រថារបៀបធ្វើ?

4. ចាត់ថ្នាក់ statement។ ដាក់ស្លាកឲ្យ statement នីមួយៗជា DDL, DML ឬ DQL៖ CREATE TABLE, SELECT, DELETE, INSERT, ALTER TABLE, UPDATE, DROP TABLE។

5. Client និង server។ ដោយពាក្យរបស់អ្នកផ្ទាល់ ពន្យល់ថាហេតុអ្វីកម្មវិធីគេហទំព័រផ្ញើ SQL ទៅ Postgres server ជំនួសឲ្យការបើកឯកសារ database ដោយផ្ទាល់។ ដាក់ឈ្មោះអត្ថប្រយោជន៍ពីរដែលកើតមកពីការដែល server ជាកម្មវិធីដាច់ដោយឡែក។

6. នៅពេលណាដែល spreadsheet គ្រប់គ្រាន់? រាយស្ថានភាពពីរដែលអ្នកនៅតែជ្រើសរើស spreadsheet និងពីរដែលអ្នកជ្រើសរើស database។ តើសញ្ញាអ្វីប្រាប់ថាដល់ពេលផ្លាស់ប្តូរ?

ទៅទីណាបន្ត។ ឥឡូវអ្នកដឹងថាហេតុអ្វីបានជា database មាន អ្វីទៅជា table និង relation អ្វីទៅជា SQL និងអ្វីដែលយើងនឹងសាងសង់។ ក្នុងជំពូកបន្ទាប់ ការដំឡើង PostgreSQL អ្នកនឹងដំណើរការ Postgres ក្នុង Docker តភ្ជាប់ដោយ psql បង្កើត database shopdb និងដំណើរការ query ដំបូងរបស់អ្នក។