ការដំឡើង PostgreSQL

មាតិកា

1. អ្វីដែលយើងនឹងដំឡើង
2. ចាប់ផ្តើម PostgreSQL ដោយ Docker
3. តភ្ជាប់ដោយ psql
4. Query ដំបូងរបស់អ្នក
5. psql Meta-Command ចាំបាច់
6. បង្កើត Database shopdb
7. បញ្ឈប់ ចាប់ផ្តើម និងរក្សាទិន្នន័យរបស់អ្នក
8. ថតឯកសារ Project shopdb
9. ការដំណើរការឯកសារ SQL និងការសាងសង់ឡើងវិញ
10. ជម្រើស៖ Client បែបក្រាហ្វិក
11. បញ្ហាទូទៅ
12. សាកល្បងដោយខ្លួនឯង

1. អ្វីដែលយើងនឹងដំឡើង

ពី ជំពូកទី 1 អ្នកដឹងថា PostgreSQL គឺជា server ហើយអ្នកនិយាយជាមួយវាដោយ client។ ក្នុងជំពូកនេះ យើងដំឡើងទាំងពីរ៖

• Server៖ PostgreSQL 17 ដែលដំណើរការក្នុង Docker container។
• Client៖ psql ជាឧបករណ៍ command-line ដែលមកជាមួយ Postgres។ យើងដំណើរការវាក្នុង container តែមួយ ដូច្នេះអ្នកមិនចាំបាច់ដំឡើងអ្វីផ្សេងទៀតទេ។
• ថតឯកសារ project ឈ្មោះ shopdb ដែលផ្ទុកឯកសារ SQL របស់អ្នក។

ហេតុអ្វីបានជា Docker? ការដំឡើង Postgres ដោយផ្ទាល់លើកុំព្យូទ័ររបស់អ្នកក៏ដំណើរការដែរ ប៉ុន្តែវាបង្កើតឯកសារ និង service ខ្ចាត់ខ្ចាយទូទាំងប្រព័ន្ធរបស់អ្នក ហើយកំណែខុសគ្នារវាង Windows, macOS និង Linux។ Container ផ្តល់ឲ្យគ្រប់គ្នានូវ Postgres 17 ដូចគ្នា ហើយការលុបវានៅពេលក្រោយមិនទុកអ្វីនៅសល់ទេ។ ប្រសិនបើអ្នកថ្មីជាមួយ Docker មេរៀន Docker CLI ពន្យល់គំនិតទាំងនោះ ប៉ុន្តែអ្នកត្រូវការតែ command ពីរបីខាងក្រោមប៉ុណ្ណោះ។

អ្នកត្រូវការ Docker Desktop (Windows ឬ macOS) ឬ Docker Engine (Linux) ដែលបានដំឡើង និងកំពុងដំណើរការ។ ពិនិត្យវា៖

docker --version

អ្នកគួរតែឃើញអ្វីមួយដូចជា Docker version 27.x.x។ កំណែថ្មីៗណាក៏បាន។

2. ចាប់ផ្តើម PostgreSQL ដោយ Docker

ដំណើរការ command តែមួយនេះ៖

docker run --name shopdb-pg -e POSTGRES_PASSWORD=postgres -p 5432:5432 -d postgres:17

Docker ទាញយក image postgres:17 ក្នុងលើកដំបូង ដែលចំណាយពេលមួយនាទី។ តោះអាន command ម្តងមួយចំណែក៖

Password postgres គ្រប់គ្រាន់សម្រាប់ database សិក្សាលើកុំព្យូទ័ររបស់អ្នកផ្ទាល់។ កុំប្រើអ្វីដែលសាមញ្ញបែបនេះសម្រាប់ database ដែលអ្នកដទៃអាចចូលប្រើបានឡើយ។ យើងនិយាយអំពីគណនីត្រឹមត្រូវក្នុងជំពូកទី 12។

ពិនិត្យថាវាកំពុងដំណើរការ៖

docker ps

លទ្ធផលធម្មតា (លុបចោលជួរឈរខ្លះ)៖

CONTAINER ID   IMAGE         STATUS         PORTS                    NAMES
3f2a9c1d7b44   postgres:17   Up 12 seconds  0.0.0.0:5432->5432/tcp   shopdb-pg

Up មានន័យថា server កំពុងដំណើរការ។ ប្រសិនបើស្ថានភាពជា Exited សូមមើល បញ្ហាទូទៅ។ អ្នកក៏អាចអាន log របស់ server បានដែរ៖

docker logs shopdb-pg

បន្ទាត់ចុងក្រោយគួរតែនិយាយថា database system is ready to accept connections។

3. តភ្ជាប់ដោយ psql

ឥឡូវបើក session psql ក្នុង container៖

docker exec -it shopdb-pg psql -U postgres

អត្ថន័យ៖ docker exec ដំណើរការ command ក្នុង container ដែលកំពុងដំណើរការ; -it ធ្វើឲ្យវាអន្តរកម្មដើម្បីឲ្យអ្នកអាចវាយ; psql -U postgres ចាប់ផ្តើម client ជាអ្នកប្រើ postgres។ ដោយសារ psql ដំណើរការលើម៉ាស៊ីនតែមួយនឹង server វាមិនសួររក password នៅទីនេះទេ។

អ្នកនឹងឃើញសារស្វាគមន៍ និង prompt មួយ៖

psql (17.x)
Type "help" for help.

postgres=#

Prompt បង្ហាញឈ្មោះ database ដែលអ្នកតភ្ជាប់ទៅ (postgres ជា database លំនាំដើម) និង # ដែលមានន័យថាអ្នកជា superuser។ ឥឡូវអ្នកស្ថិតក្នុង loop មួយ៖ វាយ SQL ឬ command ចុច Enter អានលទ្ធផល។

4. Query ដំបូងរបស់អ្នក

វាយនេះ ហើយចុច Enter៖

SELECT 1 + 1;

លទ្ធផល៖

 ?column?
----------
        2
(1 row)

អ្នកបានសួរសំណួរដោយគ្មាន table ទាល់តែសោះ ហើយ Postgres បានគណនាវា។ Column មិនមានឈ្មោះ ដូច្នេះវាបង្ហាញ ?column?។ ដាក់ឈ្មោះឲ្យវាដោយ AS៖

SELECT 1 + 1 AS answer;

 answer
--------
      2
(1 row)

សួរ server អំពីម៉ោងបច្ចុប្បន្ន៖

SELECT now();

លទ្ធផលធម្មតា (ម៉ោង និងតំបន់ពេលវេលារបស់អ្នកនឹងខុសគ្នា)៖

              now
-------------------------------
 2026-10-03 09:41:17.382914+00
(1 row)

ហើយសួរថាអ្នកកំពុងដំណើរការកំណែអ្វី៖

SELECT version();

លទ្ធផលធម្មតា៖

                                version
-----------------------------------------------------------------------
 PostgreSQL 17.x (Debian ...) on aarch64-unknown-linux-gnu, compiled by ...
(1 row)

ទម្លាប់ពីរដែលត្រូវបង្កើតឥឡូវនេះ៖

1. បញ្ចប់រាល់ SQL statement ដោយ ;។ ប្រសិនបើអ្នកភ្លេច psql គិតថាអ្នកនៅតែកំពុងវាយ ហើយបង្ហាញ prompt បន្ត postgres-#។ វាយ ; ហើយចុច Enter ដើម្បីបញ្ចប់។
2. SQL មិនប្រកាន់អក្សរតូចធំសម្រាប់ keyword ទេ។ select 1+1; ក៏ដំណើរការដែរ។ យើងសរសេរ keyword ជាអក្សរធំដើម្បីងាយអាន។

តម្លៃអក្សរដាក់ក្នុង single quote៖

SELECT 'Hello, database' AS greeting;

     greeting
-----------------
 Hello, database
(1 row)

Double quote មានន័យផ្សេងក្នុង SQL៖ វាសម្គាល់ identifier ដូចជាឈ្មោះ column។ ការច្រឡំពួកវាគឺជាកំហុសធម្មតាបំផុតរបស់អ្នកចាប់ផ្តើម។

5. psql Meta-Command ចាំបាច់

ក្រៅពី SQL, psql មាន command ផ្ទាល់ខ្លួនដែលចាប់ផ្តើមដោយ backslash។ ពួកវាមិនមែនជា SQL ទេ មិនត្រូវបានផ្ញើទៅ server ទេ ហើយមិនបញ្ចប់ដោយសញ្ញាចុច-ក្បៀសទេ។ នេះគឺជាអ្វីដែលអ្នកនឹងប្រើគ្រប់ពេល៖

សាកល្បងមួយដំបូង៖

postgres=# \l

លទ្ធផលធម្មតា (កាត់បន្ថយ)៖

                              List of databases
   Name    |  Owner   | Encoding | ...
-----------+----------+----------+----
 postgres  | postgres | UTF8     | ...
 template0 | postgres | UTF8     | ...
 template1 | postgres | UTF8     | ...
(3 rows)

postgres គឺជា database លំនាំដើម។ template0 និង template1 គឺជា template ដែល Postgres ចម្លងនៅពេលអ្នកបង្កើត database ថ្មី។ កុំប៉ះពួកវា។

\x ជួយនៅពេល row ទូលាយពេកសម្រាប់អេក្រង់របស់អ្នក។ ពេលបើកលទ្ធផលបែបពង្រីក row នីមួយៗត្រូវបានបង្ហាញជាបញ្ជីបញ្ឈរ៖

postgres=# \x
Expanded display is on.
postgres=# SELECT 1 + 1 AS answer, now() AS time;
-[ RECORD 1 ]----------------------------
answer | 2
time   | 2026-10-03 09:44:02.118733+00

វាយ \x ម្តងទៀតដើម្បីបិទវា។ ហើយ \timing មានប្រយោជន៍នៅពេលក្រោយក្នុងជំពូកទី 11៖

postgres=# \timing
Timing is on.
postgres=# SELECT 1;
 ?column?
----------
        1
(1 row)

Time: 0.412 ms

ចំណាំថា command ក្រុម \d (\dt, \d customers និងផ្សេងទៀតដូចជា \di សម្រាប់ index) គឺជារបៀបដែលអ្នកមើល schema របស់អ្នកផ្ទាល់។ អ្នកនឹងប្រើ \d ក្រោយស្ទើរតែរាល់ការផ្លាស់ប្តូរក្នុងជំពូកបន្ទាប់ៗ។

6. បង្កើត Database shopdb

Database លំនាំដើម postgres គឺសម្រាប់ការគ្រប់គ្រង។ Project នីមួយៗគួរមាន database ផ្ទាល់ខ្លួន។ បង្កើតមួយដោយ DDL statement ដំបូងនៃស៊េរី៖

CREATE DATABASE shopdb;

លទ្ធផល៖

CREATE DATABASE

Postgres ឆ្លើយតបដោយឈ្មោះ command ដែលវាបានដំណើរការ។ ឥឡូវតភ្ជាប់ទៅវា៖

postgres=# \c shopdb
You are now connected to database "shopdb" as user "postgres".
shopdb=#

សូមកត់សម្គាល់ថា prompt ប្តូរទៅ shopdb=#។ គ្រប់ table ដែលអ្នកបង្កើតពីពេលនេះទៅ នឹងស្ថិតក្នុង database នេះ។ ពិនិត្យថាវាទទេ៖

shopdb=# \dt
Did not find any relations.

ក្នុង Postgres "relation" គឺជាពាក្យទូទៅសម្រាប់ table, view និងវត្ថុដូច table ផ្សេងទៀត។ មិនទាន់មាន table ទេ ដែលជាអ្វីដែលយើងរំពឹង។

លើកក្រោយ អ្នកអាចលោតត្រង់ចូល database ពី terminal របស់អ្នក៖

docker exec -it shopdb-pg psql -U postgres -d shopdb

Option -d shopdb ជ្រើសរើស database។ នេះគឺជា command ដែលអ្នកនឹងប្រើនៅដើមជំពូកនីមួយៗ។ ចាកចេញពី psql ដោយ \q ឬចុច Ctrl+D។

7. បញ្ឈប់ ចាប់ផ្តើម និងរក្សាទិន្នន័យរបស់អ្នក

នៅពេលអ្នករួចរាល់សម្រាប់ថ្ងៃនោះ អ្នកមិនចាំបាច់រក្សា server ឲ្យដំណើរការទេ៖

docker stop shopdb-pg

លើកក្រោយ ចាប់ផ្តើមវាម្តងទៀតដោយ៖

docker start shopdb-pg

ការបញ្ឈប់ និងចាប់ផ្តើម container រក្សាទិន្នន័យរបស់វា។ អ្វីៗទាំងអស់ដែលអ្នកបានបង្កើតក្នុង shopdb នៅតែមាន។

ប៉ុន្តែមានចំណុចចាប់មួយ។ ទិន្នន័យស្ថិត នៅក្នុង container។ ប្រសិនបើអ្នកលុប container ដោយ docker rm ទិន្នន័យក៏បាត់ទៅជាមួយដែរ។ នោះមិនអីសម្រាប់ការរៀន ហើយតាមពិតយើងពឹងលើវា៖ អ្នកអាចលុប និងសាងសង់ឡើងវិញគ្រប់ពេល។ ប្រសិនបើអ្នកចង់រក្សាទិន្នន័យ សូម្បីពេល container ត្រូវបានជំនួស សូមរក្សាទុកវាក្នុង volume ដែលជាថតដែល Docker គ្រប់គ្រងនៅខាងក្រៅ container។ អ្នកត្រូវសម្រេចចិត្តរឿងនេះនៅពេលអ្នកបង្កើត container ដំបូង។ ដើម្បីប្រើ volume សូមលុប container ចាស់ ហើយបង្កើតវាម្តងទៀតជាមួយ -v៖

docker rm -f shopdb-pg
docker run --name shopdb-pg -e POSTGRES_PASSWORD=postgres -p 5432:5432 \
  -v shopdb-data:/var/lib/postgresql/data -d postgres:17

-v shopdb-data:/var/lib/postgresql/data មានន័យថា "mount Docker volume ឈ្មោះ shopdb-data នៅថតដែល Postgres រក្សាទុកឯកសាររបស់វា"។ Volume នៅរស់ សូម្បីតែអ្នកលុប container។ នៅពេលអ្នកចាប់ផ្តើម container ថ្មីដោយ -v ដូចគ្នា ទិន្នន័យត្រឡប់មកវិញ។ ដើម្បីលុប volume ផងដែរ ហើយចាប់ផ្តើមស្រស់ទាំងស្រុង៖

docker rm -f shopdb-pg
docker volume rm shopdb-data

នេះគឺជាការប្រៀបធៀបរហ័សនៃ command ទាំងនេះ៖

សម្រាប់ស៊េរីនេះ ជម្រើសណាក៏បាន ព្រោះយើងនឹងរក្សាការងារទាំងអស់របស់យើងក្នុងឯកសារ SQL ដែលអាចសាងសង់អ្វីៗទាំងអស់ឡើងវិញ។

8. ថតឯកសារ Project shopdb

នេះគឺជាទម្លាប់ដែលញែកអ្នកចាប់ផ្តើមចេញពីអ្នកជំនាញ៖ កុំគ្រាន់តែវាយ SQL ក្នុង prompt។ រក្សាទុកវាក្នុងឯកសារ។ Statement ដែលវាយក្នុង prompt បាត់នៅពេលអ្នកបិទ session។ ឯកសារក្នុងថតអាចដំណើរការម្តងទៀត កែ ចែករំលែក និងដាក់ក្នុង Git។

បង្កើតថតមួយនៅកន្លែងណាក៏បានលើកុំព្យូទ័ររបស់អ្នក (មិនមែនក្នុង container ទេ)៖

mkdir shopdb
cd shopdb
mkdir queries
touch schema.sql seed.sql

រចនាសម្ព័ន្ធ៖

shopdb/
  schema.sql      <- សេចក្តីថ្លែង CREATE TABLE (ជំពូកទី 3 និង 6)
  seed.sql        <- សេចក្តីថ្លែង INSERT ជាមួយទិន្នន័យគំរូ (ជំពូកទី 4 និង 6)
  queries/        <- សំណួរផ្ទាល់ខ្លួនរបស់អ្នក ឯកសារ .sql មួយក្នុងមួយប្រធានបទ

ជំពូកនីមួយៗប្រាប់អ្នកថាកូដត្រូវដាក់ក្នុងឯកសារមួយណា៖

• schema.sql ផ្ទុករចនាសម្ព័ន្ធ (DDL)៖ table និងច្បាប់។
• seed.sql ផ្ទុកទិន្នន័យចាប់ផ្តើម (DML)៖ row សម្រាប់បំពេញ table។
• queries/ ផ្ទុក SELECT statement ដែលអ្នកចង់រក្សា។

ប្រសិនបើអ្នកប្រើ Git (មើល Git និង GitHub សម្រាប់អ្នកចាប់ផ្តើម) ដំណើរការ git init នៅទីនេះ ហើយ commit ក្រោយជំពូកនីមួយៗ។ ថត shopdb ក្លាយជា project ពិតប្រាកដដែលមានការគ្រប់គ្រងកំណែ។

ប្រើ editor ណាក៏បានដែលអ្នកចូលចិត្ត ដូចជា VS Code។ ឯកសារ SQL គឺជាអក្សរធម្មតាដែលមានផ្នែកបន្ថែម .sql។

9. ការដំណើរការឯកសារ SQL និងការសាងសង់ឡើងវិញ

អ្នកអាចដំណើរការឯកសារតាមពីរវិធី។

ពី terminal របស់អ្នកផ្ទាល់ ដោយបញ្ចូលឯកសារទៅ psql ក្នុង container។ Flag -i (គ្មាន -t) អនុញ្ញាតឲ្យ Docker អានពី standard input៖

docker exec -i shopdb-pg psql -U postgres -d shopdb < schema.sql

< គឺជា "អាន input ពីឯកសារនេះ" របស់ shell។ ដំណើរការវាពីក្នុងថត shopdb/។ នេះគឺជាទម្រង់ដែលយើងប្រើពេញមួយស៊េរី។

ពីក្នុង psql ដោយ \i ដែលត្រូវការ path ដែល psql មើលឃើញ។ ដោយសារ psql ដំណើរការក្នុង container វាមើលមិនឃើញឯកសារលើកុំព្យូទ័ររបស់អ្នកទេ។ ដូច្នេះទម្រង់ទីមួយគឺជាទម្រង់ជាក់ស្តែង។

តោះបង្កើតអ្វីមួយសម្រាប់ដំណើរការ។ ដាក់នេះក្នុង queries/hello.sql៖

SELECT 'shopdb is ready' AS status, now() AS checked_at;

ដំណើរការវា៖

docker exec -i shopdb-pg psql -U postgres -d shopdb < queries/hello.sql

លទ្ធផលធម្មតា៖

     status      |          checked_at
-----------------+-------------------------------
 shopdb is ready | 2026-10-03 09:58:40.204118+00
(1 row)

ឥឡូវគិតអំពី ការសាងសង់ឡើងវិញ។ ក្នុងអំឡុងស៊េរី អ្នកនឹងចង់ចាប់ផ្តើមឡើងវិញច្រើនដង៖ បន្ទាប់ពីមានកំហុស ឬដើម្បីមើលថាឯកសាររបស់អ្នកដំណើរការពិតឬអត់។ ដើម្បីលុប និងបង្កើត database ឡើងវិញ សូមដំណើរការ command ពីរនេះ៖

docker exec -i shopdb-pg psql -U postgres -c "DROP DATABASE IF EXISTS shopdb;"
docker exec -i shopdb-pg psql -U postgres -c "CREATE DATABASE shopdb;"

-c មានន័យថា "ដំណើរការ SQL command តែមួយនេះ ហើយចេញ"។ ត្រូវប្រុងប្រយ័ត្នជាមួយ DROP DATABASE៖ វាលុបអ្វីៗទាំងអស់ក្នុង shopdb ភ្លាមៗ និងជាអចិន្ត្រៃយ៍ ដោយគ្មាន "តើអ្នកប្រាកដឬទេ?"។ វាមានសុវត្ថិភាពនៅទីនេះ ព្រោះទិន្នន័យជាទិន្នន័យហាត់ ហើយឯកសាររបស់អ្នកអាចបង្កើតវាឡើងវិញបាន។

បន្ទាប់មកសាងសង់ឡើងវិញដោយឯកសាររបស់អ្នក៖

docker exec -i shopdb-pg psql -U postgres -d shopdb < schema.sql
docker exec -i shopdb-pg psql -U postgres -d shopdb < seed.sql

ពីរ command ហើយ database ទាំងមូលរបស់អ្នកត្រឡប់មកវិញក្នុងមួយវិនាទី។ ក្នុងជំពូកក្រោយៗ យើងនឹងប្រើ command ទាំងបួននេះជា "រូបមន្តសាងសង់ឡើងវិញ"។ អ្នកប្រហែលជាចង់រក្សាទុកពួកវាក្នុង shell script តូចមួយឈ្មោះ rebuild.sh នៅក្នុង shopdb/៖

#!/bin/sh
PSQL="docker exec -i shopdb-pg psql -U postgres"
$PSQL -c "DROP DATABASE IF EXISTS shopdb;"
$PSQL -c "CREATE DATABASE shopdb;"
$PSQL -d shopdb < schema.sql
$PSQL -d shopdb < seed.sql

ដំណើរការវាដោយ sh rebuild.sh។ វាប្រើ command ដូចគ្នាបេះបិទនឹងខាងលើ ដោយផ្នែកដែលធ្វើឡើងវិញត្រូវបានរក្សាទុកក្នុង variable។

10. ជម្រើស៖ Client បែបក្រាហ្វិក

psql គឺជាអ្វីគ្រប់យ៉ាងដែលអ្នកត្រូវការ ហើយការរៀនវាផ្តល់ផលល្អ ព្រោះវាមានលើគ្រប់ server។ ប៉ុន្តែ client បែបក្រាហ្វិកអាចល្អសម្រាប់រកមើល table។ ជម្រើសឥតគិតថ្លៃដែលពេញនិយមពីរ៖

• DBeaver (ឥតគិតថ្លៃ គ្រប់ platform)៖ ឧបករណ៍ database ទូទៅដែលមាន table browser និង query editor។
• TablePlus (macOS, Windows, Linux)៖ ចំណុចប្រទាក់ស្អាត និងលឿន ដែលមានកំណែឥតគិតថ្លៃ។

ដើម្បីតភ្ជាប់ពី client បែបក្រាហ្វិក អ្នកប្រើ port ដែលយើងបានបើកជាមួយ -p 5432:5432។ ការកំណត់គឺ៖

នេះក៏ជារបៀបដែលកម្មវិធីផ្ទាល់ខ្លួនរបស់អ្នក ដូចជា script Node.js ក្នុងជំពូកទី 12 នឹងតភ្ជាប់ដែរ។ ពីខាងក្រៅ container server អាចចូលបាននៅ localhost:5432។

11. បញ្ហាទូទៅ

នៅពេលមានអ្វីមួយខុស docker ps -a (បង្ហាញ container ដែលបានបញ្ឈប់ផងដែរ) និង docker logs shopdb-pg ឆ្លើយសំណួរភាគច្រើន។

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

1. ដំណើរការការដំឡើង។ ចាប់ផ្តើម container បើក psql ហើយដំណើរការ SELECT version();។ តើអ្នកឃើញកំណែធំណានៃ PostgreSQL?
2. គណនាក្នុង SQL។ ដោយគ្មាន table ណាមួយ សរសេរ query មួយដែលត្រឡប់បី column៖ 7 * 6 ជា product, 10 / 4 ជា integer_division និង 10 / 4.0 ជា decimal_division។ តើ Postgres ធ្វើអ្វីជាមួយ 10 / 4 ហើយអ្នកគិតថាហេតុអ្វីបានជាបែបនោះ?
3. រុករកដោយ meta-command។ ប្រើ \l បន្ទាប់មក \c shopdb បន្ទាប់មក \dt។ បន្ទាប់មកដំណើរការ \timing និង SELECT now();។ កត់សម្គាល់បន្ទាត់ Time:។ បិទ timing ម្តងទៀត។
4. ដាក់ quote ឲ្យត្រឹមត្រូវ។ ដំណើរការ SELECT 'It''s ready';។ តើការដាក់ single quote ទ្វេធ្វើអ្វី? បន្ទាប់មកសាកល្បង SELECT "text"; ហើយអានសារកំហុស។ តើ Postgres គិតថា "text" ជាអ្វី?
5. សាងសង់ថតឯកសារ។ បង្កើតថត shopdb/ ជាមួយ schema.sql, seed.sql និង queries/។ ដាក់ query hello.sql របស់អ្នកក្នុង queries/ ហើយដំណើរការវាដោយទម្រង់ docker exec -i ... < file។
6. សាងសង់វាឡើងវិញ។ សរសេរ rebuild.sh ដំណើរការវា ហើយបញ្ជាក់ដោយ \l ថា shopdb មាន។ បន្ទាប់មកបញ្ឈប់ container ចាប់ផ្តើមវាម្តងទៀត ហើយពិនិត្យថា database នៅតែមាន។

ទៅទីណាបន្ត។ អ្នកមាន PostgreSQL server ដែលកំពុងដំណើរការ, psql ដែលដំណើរការបាន, database shopdb ទទេ និងថតឯកសារ project ដែលអាចសាងសង់វាឡើងវិញបាន។ ក្នុងជំពូកបន្ទាប់ Table, Data Type និង Constraint អ្នកនឹងសរសេរ CREATE TABLE statement ដំបូង ហើយរៀនពីរបៀបដែលច្បាប់រារាំងទិន្នន័យអាក្រក់។