ដូច្នេះ យើង​បាន​ពិចារណា​លើ​បញ្ហា​ដែល​ទាក់ទង​នឹង អ៊ីសូឡង់និងបានធ្វើការដកថយអំពី រៀបចំទិន្នន័យនៅកម្រិតទាប. ហើយទីបំផុតយើងបានទៅដល់ផ្នែកដែលគួរឱ្យចាប់អារម្មណ៍បំផុត - កំណែខ្សែអក្សរ។

បឋមកថា

ដូចដែលយើងបាននិយាយរួចមកហើយ ជួរនីមួយៗអាចមានក្នុងពេលដំណាលគ្នានៅក្នុងកំណែជាច្រើននៅក្នុងមូលដ្ឋានទិន្នន័យ។ កំណែ​មួយ​ត្រូវ​តែ​មាន​លក្ខណៈ​ខុស​ប្លែក​ពី​កំណែ​មួយ​ផ្សេង​ទៀត​។ សម្រាប់​គោល​បំណង​នេះ កំណែ​នីមួយៗ​មាន​សញ្ញា​ពីរ​ដែល​កំណត់ "ពេលវេលា" នៃ​សកម្មភាព​នៃ​កំណែ​នេះ (xmin និង xmax)។ នៅក្នុងសម្រង់ - ដោយសារតែវាមិនមែនជាពេលវេលាដូចដែលត្រូវបានប្រើនោះទេប៉ុន្តែការរាប់កើនឡើងពិសេស។ ហើយបញ្ជរនេះគឺជាលេខប្រតិបត្តិការ។

(ដូចធម្មតា ការពិតកាន់តែស្មុគស្មាញ៖ លេខប្រតិបត្តិការមិនអាចកើនឡើងគ្រប់ពេលទេ ដោយសារសមត្ថភាពប៊ីតមានកំណត់របស់បញ្ជរ។ ប៉ុន្តែយើងនឹងពិនិត្យមើលព័ត៌មានលម្អិតទាំងនេះឱ្យបានលម្អិតនៅពេលយើងឈានដល់ការបង្កក។)

នៅពេលដែលជួរដេកមួយត្រូវបានបង្កើត xmin ត្រូវបានកំណត់ទៅលេខប្រតិបត្តិការដែលបានចេញពាក្យបញ្ជា INSERT ហើយ xmax ត្រូវបានទុកចោល។

នៅពេលដែលជួរដេកមួយត្រូវបានលុប តម្លៃ xmax នៃកំណែបច្ចុប្បន្នត្រូវបានសម្គាល់ដោយចំនួននៃប្រតិបត្តិការដែលបានអនុវត្តការលុប។

នៅពេលដែលជួរមួយត្រូវបានកែប្រែដោយពាក្យបញ្ជា UPDATE ប្រតិបត្តិការពីរត្រូវបានអនុវត្តយ៉ាងពិតប្រាកដ៖ DELETE និង INSERT ។ កំណែបច្ចុប្បន្ននៃជួរដេកកំណត់ xmax ស្មើនឹងចំនួនប្រតិបត្តិការដែលបានធ្វើ UPDATE ។ បន្ទាប់មកកំណែថ្មីនៃខ្សែអក្សរដូចគ្នាត្រូវបានបង្កើត។ តម្លៃ xmin របស់វាស្របគ្នានឹងតម្លៃ xmax នៃកំណែមុន។

វាល xmin និង xmax ត្រូវបានរួមបញ្ចូលនៅក្នុងបឋមកថាកំណែជួរ។ បន្ថែមពីលើវាលទាំងនេះ បឋមកថាមានផ្សេងទៀត ឧទាហរណ៍៖

• infomask គឺជាស៊េរីនៃប៊ីតដែលកំណត់លក្ខណៈសម្បត្តិនៃកំណែនេះ។ មានច្រើនណាស់នៃពួកគេ; យើងនឹងពិចារណាបន្តិចម្តង ៗ
• ctid គឺ​ជា​តំណ​ទៅ​កាន់​កំណែ​ថ្មី​បន្ទាប់​នៃ​បន្ទាត់​ដូច​គ្នា។ សម្រាប់​កំណែ​បច្ចុប្បន្ន​បំផុត​នៃ​ខ្សែ​អក្សរ ctid សំដៅ​លើ​កំណែ​នេះ​ខ្លួន​ឯង។ លេខមានទម្រង់ (x,y) ដែល x ជាលេខទំព័រ y ជាលេខលិបិក្រមក្នុងអារេ។
• null bitmap - សម្គាល់ជួរឈរទាំងនោះនៃកំណែដែលបានផ្តល់ឱ្យដែលមានតម្លៃទទេ (NULL) ។ NULL មិនមែនជាតម្លៃប្រភេទទិន្នន័យធម្មតាមួយទេ ដូច្នេះគុណលក្ខណៈត្រូវតែរក្សាទុកដោយឡែកពីគ្នា។

ជាលទ្ធផល បឋមកថាមានទំហំធំណាស់ - យ៉ាងហោចណាស់ 23 បៃសម្រាប់កំណែនីមួយៗនៃបន្ទាត់ ហើយជាធម្មតាច្រើនជាងនេះដោយសារតែ NULL bitmap ។ ប្រសិនបើតារាងគឺ "តូចចង្អៀត" (នោះគឺមានជួរឈរពីរបី) នោះតម្លៃលើសអាចទទួលយកច្រើនជាងព័ត៌មានដែលមានប្រយោជន៍។

បញ្ចូល

ចូរយើងពិនិត្យមើលឱ្យកាន់តែច្បាស់អំពីរបៀបដែលប្រតិបត្តិការខ្សែអក្សរកម្រិតទាបត្រូវបានអនុវត្ត ដោយចាប់ផ្តើមជាមួយនឹងការបញ្ចូល។

សម្រាប់ការពិសោធន៍ យើងបង្កើតតារាងថ្មីដែលមានជួរឈរពីរ និងលិបិក្រមលើមួយក្នុងចំណោមពួកវា៖

=> CREATE TABLE t(
  id serial,
  s text
);
=> CREATE INDEX ON t(s);

សូមបញ្ចូលជួរមួយបន្ទាប់ពីចាប់ផ្តើមប្រតិបត្តិការ។

=> BEGIN;
=> INSERT INTO t(s) VALUES ('FOO');

នេះគឺជាលេខប្រតិបត្តិការបច្ចុប្បន្នរបស់យើង៖

=> SELECT txid_current();

 txid_current 
--------------
         3664
(1 row)

សូមក្រឡេកមើលខ្លឹមសារនៃទំព័រ។ មុខងារ heap_page_items នៃផ្នែកបន្ថែម pageinspect អនុញ្ញាតឱ្យអ្នកទទួលបានព័ត៌មានអំពីទ្រនិច និងកំណែជួរ៖

=> SELECT * FROM heap_page_items(get_raw_page('t',0)) gx

-[ RECORD 1 ]-------------------
lp          | 1
lp_off      | 8160
lp_flags    | 1
lp_len      | 32
t_xmin      | 3664
t_xmax      | 0
t_field3    | 0
t_ctid      | (0,1)
t_infomask2 | 2
t_infomask  | 2050
t_hoff      | 24
t_bits      | 
t_oid       | 
t_data      | x0100000009464f4f

ចំណាំថាពាក្យ heap នៅក្នុង PostgreSQL សំដៅលើតារាង។ នេះ​ជា​ការ​ប្រើ​ពាក្យ​ចម្លែក​មួយ​ទៀត​នៃ​ពាក្យ​នេះ - heap ត្រូវ​បាន​គេ​ស្គាល់ រចនាសម្ព័ន្ធទិន្នន័យដែលមិនមានអ្វីដូចគ្នាជាមួយតារាង។ នៅទីនេះពាក្យនេះត្រូវបានប្រើក្នុងន័យនៃ "អ្វីគ្រប់យ៉ាងត្រូវបានបោះរួមគ្នា" ផ្ទុយទៅនឹងលិបិក្រមដែលបានបញ្ជា។

មុខងារបង្ហាញទិន្នន័យ “ដូច” ជាទម្រង់ដែលពិបាកយល់។ ដើម្បីស្វែងយល់ យើងនឹងទុកតែផ្នែកនៃព័ត៌មាន ហើយបកស្រាយវា៖

=> SELECT '(0,'||lp||')' AS ctid,
       CASE lp_flags
         WHEN 0 THEN 'unused'
         WHEN 1 THEN 'normal'
         WHEN 2 THEN 'redirect to '||lp_off
         WHEN 3 THEN 'dead'
       END AS state,
       t_xmin as xmin,
       t_xmax as xmax,
       (t_infomask & 256) > 0  AS xmin_commited,
       (t_infomask & 512) > 0  AS xmin_aborted,
       (t_infomask & 1024) > 0 AS xmax_commited,
       (t_infomask & 2048) > 0 AS xmax_aborted,
       t_ctid
FROM heap_page_items(get_raw_page('t',0)) gx

-[ RECORD 1 ]-+-------
ctid          | (0,1)
state         | normal
xmin          | 3664
xmax          | 0
xmin_commited | f
xmin_aborted  | f
xmax_commited | f
xmax_aborted  | t
t_ctid        | (0,1)

នេះជាអ្វីដែលយើងបានធ្វើ៖

• បន្ថែមលេខសូន្យទៅលេខលិបិក្រម ដើម្បីឱ្យវាមើលទៅដូច t_ctid៖ (លេខទំព័រ លេខលិបិក្រម)។
• ឌិគ្រីបស្ថានភាពនៃទ្រនិច lp_flags ។ នៅទីនេះវា "ធម្មតា" - នេះមានន័យថាទ្រនិចពិតជាសំដៅទៅលើកំណែនៃខ្សែអក្សរ។ យើងនឹងមើលអត្ថន័យផ្សេងទៀតនៅពេលក្រោយ។
• ក្នុងចំណោមព័ត៌មានទាំងអស់ មានតែពីរគូប៉ុណ្ណោះដែលត្រូវបានកំណត់អត្តសញ្ញាណរហូតមកដល់ពេលនេះ។ ប៊ីត xmin_committed និង xmin_aborted បង្ហាញថាតើលេខប្រតិបត្តិការ xmin ត្រូវបានប្តេជ្ញាចិត្ត (បោះបង់)។ ប៊ីតស្រដៀងគ្នាពីរសំដៅលើលេខប្រតិបត្តិការ xmax ។

តើយើងឃើញអ្វី? នៅពេលអ្នកបញ្ចូលជួរដេក លិបិក្រមលេខ 1 នឹងបង្ហាញនៅក្នុងទំព័រតារាង ដោយចង្អុលទៅកំណែទីមួយ និងតែមួយគត់នៃជួរដេក។

នៅក្នុងកំណែខ្សែអក្សរ វាល xmin ត្រូវបានបំពេញដោយលេខប្រតិបត្តិការបច្ចុប្បន្ន។ ប្រតិបត្តិការនៅតែសកម្ម ដូច្នេះទាំង xmin_committed និង xmin_aborted bits មិនត្រូវបានកំណត់ទេ។

វាល ctid កំណែ​ជួរ​ដេក​សំដៅ​ទៅ​លើ​ជួរ​ដេក​ដូច​គ្នា។ នេះមានន័យថាមិនមានកំណែថ្មីជាងនេះទេ។

វាល xmax ត្រូវ​បាន​បំពេញ​ដោយ​លេខ​អត់ចេះ​សោះ 0 ព្រោះ​កំណែ​នៃ​ជួរ​ដេក​នេះ​មិន​ត្រូវ​បាន​លុប​ចេញ​ទេ ហើយ​គឺ​បច្ចុប្បន្ន។ ប្រតិបត្តិការនឹងមិនយកចិត្តទុកដាក់ចំពោះលេខនេះទេ ដោយសារ xmax_aborted bit ត្រូវបានកំណត់។

ចូរយើងបោះជំហានមួយបន្ថែមទៀតឆ្ពោះទៅរកការកែលម្អលទ្ធភាពអានដោយបន្ថែមព័ត៌មានប៊ីតទៅលេខប្រតិបត្តិការ។ ហើយតោះបង្កើតមុខងារមួយ ព្រោះយើងនឹងត្រូវការសំណើច្រើនជាងម្តង៖

=> CREATE FUNCTION heap_page(relname text, pageno integer)
RETURNS TABLE(ctid tid, state text, xmin text, xmax text, t_ctid tid)
AS $$
SELECT (pageno,lp)::text::tid AS ctid,
       CASE lp_flags
         WHEN 0 THEN 'unused'
         WHEN 1 THEN 'normal'
         WHEN 2 THEN 'redirect to '||lp_off
         WHEN 3 THEN 'dead'
       END AS state,
       t_xmin || CASE
         WHEN (t_infomask & 256) > 0 THEN ' (c)'
         WHEN (t_infomask & 512) > 0 THEN ' (a)'
         ELSE ''
       END AS xmin,
       t_xmax || CASE
         WHEN (t_infomask & 1024) > 0 THEN ' (c)'
         WHEN (t_infomask & 2048) > 0 THEN ' (a)'
         ELSE ''
       END AS xmax,
       t_ctid
FROM heap_page_items(get_raw_page(relname,pageno))
ORDER BY lp;
$$ LANGUAGE SQL;

ក្នុងទម្រង់នេះ វាកាន់តែច្បាស់អំពីអ្វីដែលកំពុងកើតឡើងនៅក្នុងបឋមកថានៃកំណែជួរ៖

=> SELECT * FROM heap_page('t',0);

 ctid  | state  | xmin | xmax  | t_ctid 
-------+--------+------+-------+--------
 (0,1) | normal | 3664 | 0 (a) | (0,1)
(1 row)

ស្រដៀងគ្នា ប៉ុន្តែមិនសូវលម្អិតទេ ព័ត៌មានអាចទទួលបានពីតារាងដោយខ្លួនឯង ដោយប្រើ pseudo-columns xmin និង xmax៖

=> SELECT xmin, xmax, * FROM t;

 xmin | xmax | id |  s  
------+------+----+-----
 3664 |    0 |  1 | FOO
(1 row)

ការជួសជុល

ប្រសិនបើប្រតិបត្តិការត្រូវបានបញ្ចប់ដោយជោគជ័យ អ្នកត្រូវចងចាំស្ថានភាពរបស់វា - ចំណាំថាវាត្រូវបានប្តេជ្ញាចិត្ត។ ដើម្បីធ្វើដូច្នេះ រចនាសម្ព័ន្ធដែលហៅថា XACT ត្រូវបានប្រើ (ហើយមុនកំណែ 10 វាត្រូវបានគេហៅថា CLOG (commit log) ហើយឈ្មោះនេះនៅតែអាចរកឃើញនៅកន្លែងផ្សេងៗគ្នា)។

XACT មិនមែនជាតារាងកាតាឡុកប្រព័ន្ធទេ។ ទាំងនេះគឺជាឯកសារនៅក្នុងថតឯកសារ PGDATA/pg_xact ។ ពួកគេមានពីរប៊ីតសម្រាប់ប្រតិបត្តិការនីមួយៗ៖ ប្តេជ្ញាចិត្ត និងលុបចោល - ដូចនៅក្នុងបឋមកថាកំណែជួរ។ ព័ត៌មាននេះត្រូវបានបែងចែកទៅជាឯកសារជាច្រើនសម្រាប់ភាពងាយស្រួលតែប៉ុណ្ណោះ យើងនឹងត្រលប់ទៅបញ្ហានេះវិញនៅពេលដែលយើងពិចារណាពីការបង្កក។ ហើយការធ្វើការជាមួយឯកសារទាំងនេះត្រូវបានអនុវត្តមួយទំព័រដោយទំព័រដូចជាជាមួយអ្នកដទៃទាំងអស់។

ដូច្នេះ នៅពេលដែលប្រតិបត្តិការមួយត្រូវបានប្រព្រឹត្តនៅក្នុង XACT ប៊ីតដែលបានប្តេជ្ញាចិត្តត្រូវបានកំណត់សម្រាប់ប្រតិបត្តិការនេះ។ ហើយនេះជាអ្វីទាំងអស់ដែលកើតឡើងកំឡុងពេលប្រព្រឹត្ត (ទោះបីជាយើងមិនទាន់និយាយអំពីកំណត់ហេតុនៃការថតទុកមុនក៏ដោយ)។

នៅពេលដែលប្រតិបត្តិការមួយផ្សេងទៀតចូលទៅកាន់ទំព័រតារាងដែលយើងទើបតែបានមើល វានឹងត្រូវឆ្លើយសំណួរជាច្រើន។

1. តើប្រតិបត្តិការ xmin បានបញ្ចប់ហើយឬនៅ? បើមិនដូច្នោះទេ កំណែដែលបានបង្កើតនៃខ្សែអក្សរមិនគួរត្រូវបានមើលឃើញទេ។
   ការត្រួតពិនិត្យនេះត្រូវបានអនុវត្តដោយមើលរចនាសម្ព័ន្ធមួយផ្សេងទៀតដែលមានទីតាំងនៅក្នុងអង្គចងចាំរួមនៃវត្ថុហើយត្រូវបានគេហៅថា ProcArray ។ វាមានបញ្ជីនៃដំណើរការសកម្មទាំងអស់ ហើយសម្រាប់លេខនីមួយៗនៃប្រតិបត្តិការបច្ចុប្បន្ន (សកម្ម) របស់វាត្រូវបានចង្អុលបង្ហាញ។
2. ប្រសិនបើបានបញ្ចប់ តើធ្វើដូចម្តេច - ដោយការប្តេជ្ញាចិត្ត ឬលុបចោល? ប្រសិន​បើ​បាន​បោះបង់ នោះ​កំណែ​ជួរ​ដេក​ក៏​មិន​គួរ​មើល​ឃើញ​ដែរ។
   នេះគឺជាអ្វីដែល XACT គឺសម្រាប់។ ប៉ុន្តែទោះបីជាទំព័រចុងក្រោយរបស់ XACT ត្រូវបានរក្សាទុកក្នុងសតិបណ្ដោះអាសន្នក្នុង RAM ក៏ដោយ វានៅតែមានតម្លៃថ្លៃក្នុងការត្រួតពិនិត្យ XACT រាល់ពេល។ ដូច្នេះនៅពេលដែលស្ថានភាពប្រតិបត្តិការត្រូវបានកំណត់ វាត្រូវបានសរសេរទៅកាន់ xmin_committed និង xmin_aborted bits នៃកំណែខ្សែអក្សរ។ ប្រសិនបើប៊ីតមួយក្នុងចំណោមប៊ីតទាំងនេះត្រូវបានកំណត់ នោះស្ថានភាពនៃប្រតិបត្តិការ xmin ត្រូវបានចាត់ទុកថាស្គាល់ ហើយប្រតិបត្តិការបន្ទាប់នឹងមិនចាំបាច់ចូលប្រើ XACT ទេ។

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

ការធ្លាក់ចុះនៃការសន្សំគឺថាបន្ទាប់ពីការផ្លាស់ប្តូរ ប្រតិបត្តិការណាមួយ (សូម្បីតែមួយអនុវត្តការអានសាមញ្ញ - SELECT) អាចចាប់ផ្តើមផ្លាស់ប្តូរទំព័រទិន្នន័យនៅក្នុងឃ្លាំងផ្ទុកទិន្នន័យ។

ដូច្នេះ ចូរ​យើង​ដោះស្រាយ​ការ​ផ្លាស់ប្ដូរ។

=> COMMIT;

គ្មានអ្វីផ្លាស់ប្តូរនៅលើទំព័រទេ (ប៉ុន្តែយើងដឹងថាស្ថានភាពប្រតិបត្តិការត្រូវបានកត់ត្រារួចហើយនៅក្នុង XACT)៖

=> SELECT * FROM heap_page('t',0);

 ctid  | state  | xmin | xmax  | t_ctid 
-------+--------+------+-------+--------
 (0,1) | normal | 3664 | 0 (a) | (0,1)
(1 row)

ឥឡូវនេះប្រតិបត្តិការដែលចូលប្រើទំព័រដំបូងនឹងត្រូវកំណត់ស្ថានភាពប្រតិបត្តិការ xmin ហើយសរសេរវាទៅប៊ីតព័ត៌មាន៖

=> SELECT * FROM t;

 id |  s  
----+-----
  1 | FOO
(1 row)

=> SELECT * FROM heap_page('t',0);

 ctid  | state  |   xmin   | xmax  | t_ctid 
-------+--------+----------+-------+--------
 (0,1) | normal | 3664 (c) | 0 (a) | (0,1)
(1 row)

លុប

នៅពេលដែលជួរដេកមួយត្រូវបានលុប លេខនៃប្រតិបត្តិការលុបបច្ចុប្បន្នត្រូវបានសរសេរទៅកាន់វាល xmax នៃកំណែបច្ចុប្បន្ន ហើយ xmax_aborted bit ត្រូវបានជម្រះ។

ចំណាំថាតម្លៃកំណត់នៃ xmax ដែលត្រូវគ្នានឹងប្រតិបត្តិការសកម្មដើរតួជាការចាក់សោជួរដេក។ ប្រសិនបើប្រតិបត្តិការផ្សេងទៀតចង់ធ្វើបច្ចុប្បន្នភាព ឬលុបជួរនេះ វានឹងត្រូវបង្ខំឱ្យរង់ចាំប្រតិបត្តិការ xmax ដើម្បីបញ្ចប់។ យើងនឹងនិយាយបន្ថែមទៀតអំពីការទប់ស្កាត់នៅពេលក្រោយ។ សម្រាប់ពេលនេះ យើងគ្រាន់តែចំណាំថាចំនួននៃការចាក់សោជួរដេកគឺគ្មានដែនកំណត់។ ពួកគេមិនយកកន្លែងទំនេរនៅក្នុង RAM ហើយដំណើរការប្រព័ន្ធមិនទទួលរងពីលេខរបស់ពួកគេទេ។ ពិត ប្រតិបត្តិការ "យូរ" មានគុណវិបត្តិផ្សេងទៀត ប៉ុន្តែមានច្រើនទៀតនៅពេលក្រោយ។

តោះលុបបន្ទាត់។

=> BEGIN;
=> DELETE FROM t;
=> SELECT txid_current();

 txid_current 
--------------
         3665
(1 row)

យើងឃើញថាលេខប្រតិបត្តិការត្រូវបានសរសេរក្នុងវាល xmax ប៉ុន្តែប៊ីតព័ត៌មានមិនត្រូវបានកំណត់ទេ៖

=> SELECT * FROM heap_page('t',0);

 ctid  | state  |   xmin   | xmax | t_ctid 
-------+--------+----------+------+--------
 (0,1) | normal | 3664 (c) | 3665 | (0,1)
(1 row)

ការលុបចោល

ការលុបចោលការផ្លាស់ប្តូរដំណើរការស្រដៀងគ្នាទៅនឹងការប្រព្រឹត្តដែរ មានតែនៅក្នុង XACT ប៉ុណ្ណោះ ប៊ីតដែលបានលុបចោលត្រូវបានកំណត់សម្រាប់ប្រតិបត្តិការ។ ការមិនធ្វើគឺលឿនដូចការប្តេជ្ញាចិត្ត។ ទោះបីជាពាក្យបញ្ជាត្រូវបានគេហៅថា ROLLBACK ការផ្លាស់ប្តូរមិនត្រូវបានត្រលប់មកវិញទេ៖ អ្វីគ្រប់យ៉ាងដែលប្រតិបត្តិការបានគ្រប់គ្រងដើម្បីផ្លាស់ប្តូរនៅក្នុងទំព័រទិន្នន័យនៅតែមិនផ្លាស់ប្តូរ។

=> ROLLBACK;
=> SELECT * FROM heap_page('t',0);

 ctid  | state  |   xmin   | xmax | t_ctid 
-------+--------+----------+------+--------
 (0,1) | normal | 3664 (c) | 3665 | (0,1)
(1 row)

នៅពេលដែលទំព័រត្រូវបានចូលប្រើ ស្ថានភាពនឹងត្រូវបានពិនិត្យ ហើយប៊ីតជំនួយ xmax_aborted នឹងត្រូវបានកំណត់ទៅជាកំណែជួរ។ លេខ xmax ខ្លួនវានៅតែមាននៅលើទំព័រ ប៉ុន្តែគ្មាននរណាម្នាក់នឹងមើលវាទេ។

=> SELECT * FROM t;

 id |  s  
----+-----
  1 | FOO
(1 row)

=> SELECT * FROM heap_page('t',0);

 ctid  | state  |   xmin   |   xmax   | t_ctid 
-------+--------+----------+----------+--------
 (0,1) | normal | 3664 (c) | 3665 (a) | (0,1)
(1 row)

ធ្វើបច្ចុប្បន្នភាព

ការអាប់ដេតដំណើរការដូចដែលវាបានលុបកំណែបច្ចុប្បន្ននៃជួរដេកដំបូង ហើយបន្ទាប់មកបញ្ចូលថ្មីមួយ។

=> BEGIN;
=> UPDATE t SET s = 'BAR';
=> SELECT txid_current();

 txid_current 
--------------
         3666
(1 row)

សំណួរបង្កើតមួយជួរ (កំណែថ្មី)៖

=> SELECT * FROM t;

 id |  s  
----+-----
  1 | BAR
(1 row)

ប៉ុន្តែនៅលើទំព័រយើងឃើញកំណែទាំងពីរ៖

=> SELECT * FROM heap_page('t',0);

 ctid  | state  |   xmin   | xmax  | t_ctid 
-------+--------+----------+-------+--------
 (0,1) | normal | 3664 (c) | 3666  | (0,2)
 (0,2) | normal | 3666     | 0 (a) | (0,2)
(2 rows)

កំណែដែលបានលុបត្រូវបានសម្គាល់ដោយលេខប្រតិបត្តិការបច្ចុប្បន្ននៅក្នុងវាល xmax ។ ជាងនេះទៅទៀត តម្លៃនេះត្រូវបានសរសេរលើតម្លៃចាស់ ចាប់តាំងពីប្រតិបត្តិការមុនត្រូវបានលុបចោល។ ហើយ xmax_aborted bit ត្រូវបានជម្រះ ដោយសារស្ថានភាពនៃប្រតិបត្តិការបច្ចុប្បន្នមិនទាន់ដឹងនៅឡើយ។

កំណែដំបូងនៃបន្ទាត់ឥឡូវនេះសំដៅទៅលើទីពីរ (t_ctid field) ជាកំណែថ្មីជាងនេះ។

លិបិក្រមទីពីរលេចឡើងក្នុងទំព័រលិបិក្រម ហើយជួរទីពីរយោងកំណែទីពីរនៅក្នុងទំព័រតារាង។

ដូចគ្នានឹងការលុបដែរ តម្លៃ xmax នៅក្នុងកំណែដំបូងនៃជួរដេកគឺជាការចង្អុលបង្ហាញថាជួរដេកត្រូវបានចាក់សោ។

ចូរយើងបញ្ចប់ប្រតិបត្តិការ។

=> COMMIT;

សន្ទស្សន៍

រហូតមកដល់ពេលនេះ យើងគ្រាន់តែនិយាយអំពីទំព័រតារាងប៉ុណ្ណោះ។ តើមានអ្វីកើតឡើងនៅក្នុងសន្ទស្សន៍?

ព័ត៌មាននៅក្នុងទំព័រលិបិក្រមប្រែប្រួលយ៉ាងខ្លាំងអាស្រ័យលើប្រភេទជាក់លាក់នៃលិបិក្រម។ ហើយសូម្បីតែប្រភេទនៃលិបិក្រមមួយក៏មានប្រភេទទំព័រផ្សេងៗគ្នាដែរ។ ឧទាហរណ៍ B-tree មានទំព័រទិន្នន័យមេតា និងទំព័រ "ទៀងទាត់" ។

ទោះយ៉ាងណាក៏ដោយ ទំព័រជាធម្មតាមានអារេនៃចង្អុលទៅជួរដេក និងជួរដេកដោយខ្លួនឯង (ដូចជាទំព័រតារាង)។ លើសពីនេះទៀតនៅចុងបញ្ចប់នៃទំព័រមានកន្លែងសម្រាប់ទិន្នន័យពិសេស។

ជួរ​ដេក​ក្នុង​លិបិក្រម​ក៏​អាច​មាន​រចនាសម្ព័ន្ធ​ខុស​គ្នា​ខ្លាំង​ដែរ​អាស្រ័យ​លើ​ប្រភេទ​សន្ទស្សន៍។ ឧទាហរណ៍ សម្រាប់​មែកធាង B ជួរ​ដែល​ទាក់ទង​នឹង​ទំព័រ​ស្លឹក​មាន​តម្លៃ​គន្លឹះ​ធ្វើ​លិបិក្រម និង​ឯកសារ​យោង (ctid) ទៅ​ជួរ​តារាង​ដែល​ត្រូវ​គ្នា។ ជាទូទៅ សន្ទស្សន៍អាចត្រូវបានរៀបចំតាមរបៀបខុសគ្នាទាំងស្រុង។

ចំណុចសំខាន់បំផុតគឺថាមិនមានកំណែជួរនៅក្នុងលិបិក្រមនៃប្រភេទណាមួយឡើយ។ ឬយើងអាចសន្មត់ថាបន្ទាត់នីមួយៗត្រូវបានតំណាងដោយកំណែជាក់លាក់មួយ។ នៅក្នុងពាក្យផ្សេងទៀត មិនមានវាល xmin និង xmax នៅក្នុងបឋមកថាជួរដេកលិបិក្រមទេ។ យើងអាចសន្មត់ថាតំណភ្ជាប់ពីលិបិក្រមនាំទៅដល់កំណែតារាងទាំងអស់នៃជួរ - ដូច្នេះអ្នកអាចស្វែងយល់ថាតើកំណែណាមួយដែលប្រតិបត្តិការនឹងឃើញដោយគ្រាន់តែមើលតារាងប៉ុណ្ណោះ។ (ដូចរាល់ដង នេះមិនមែនជាការពិតទាំងស្រុងនោះទេ។ ក្នុងករណីខ្លះ ផែនទីភាពមើលឃើញអាចបង្កើនប្រសិទ្ធភាពដំណើរការ ប៉ុន្តែយើងនឹងពិនិត្យមើលលម្អិតបន្ថែមទៀតនៅពេលក្រោយ។)

ក្នុងពេលជាមួយគ្នានេះ នៅក្នុងទំព័រលិបិក្រម យើងរកឃើញចង្អុលទៅកំណែទាំងពីរ ទាំងកំណែបច្ចុប្បន្ន និងកំណែចាស់៖

=> SELECT itemoffset, ctid FROM bt_page_items('t_s_idx',1);

 itemoffset | ctid  
------------+-------
          1 | (0,2)
          2 | (0,1)
(2 rows)

ប្រតិបត្តិការនិម្មិត

នៅក្នុងការអនុវត្ត PostgreSQL ប្រើការបង្កើនប្រសិទ្ធភាពដែលអនុញ្ញាតឱ្យវា "រក្សាទុក" លេខប្រតិបត្តិការ។

ប្រសិនបើប្រតិបត្តិការអានតែទិន្នន័យ វាមិនមានឥទ្ធិពលលើភាពមើលឃើញនៃកំណែជួរនោះទេ។ ដូច្នេះ ដំណើរការសេវាកម្មដំបូងចេញ xid និម្មិតចំពោះប្រតិបត្តិការ។ លេខមានលេខសម្គាល់ដំណើរការ និងលេខលំដាប់។

ការចេញលេខនេះមិនតម្រូវឱ្យមានការធ្វើសមកាលកម្មរវាងដំណើរការទាំងអស់ទេ ដូច្នេះហើយលឿនណាស់។ យើងនឹងស្គាល់ហេតុផលមួយទៀតសម្រាប់ការប្រើប្រាស់លេខនិម្មិត នៅពេលយើងនិយាយអំពីការបង្កក។

លេខនិម្មិតមិនត្រូវបានគេយកមកពិចារណាតាមមធ្យោបាយណាមួយនៅក្នុងរូបថតទិន្នន័យទេ។

នៅចំណុចផ្សេងគ្នានៅក្នុងពេលវេលា ប្រហែលជាមានប្រតិបត្តិការនិម្មិតនៅក្នុងប្រព័ន្ធជាមួយនឹងលេខដែលបានប្រើរួចហើយ ហើយនេះគឺជារឿងធម្មតា។ ប៉ុន្តែលេខបែបនេះមិនអាចសរសេរទៅក្នុងទំព័រទិន្នន័យបានទេ ពីព្រោះនៅពេលចូលប្រើទំព័របន្ទាប់ វាអាចបាត់បង់អត្ថន័យទាំងអស់។

=> BEGIN;
=> SELECT txid_current_if_assigned();

 txid_current_if_assigned 
--------------------------
                         
(1 row)

ប្រសិនបើប្រតិបត្តិការចាប់ផ្តើមផ្លាស់ប្តូរទិន្នន័យ វាត្រូវបានផ្តល់លេខប្រតិបត្តិការតែមួយគត់ពិតប្រាកដ។

=> UPDATE accounts SET amount = amount - 1.00;
=> SELECT txid_current_if_assigned();

 txid_current_if_assigned 
--------------------------
                     3667
(1 row)

=> COMMIT;

ប្រតិបត្តិការសម្ងាត់

សន្សំពិន្ទុ

កំណត់ក្នុង SQL សន្សំពិន្ទុ (savepoint) ដែលអនុញ្ញាតឱ្យអ្នកលុបចោលផ្នែកនៃប្រតិបត្តិការដោយមិនរំខានវាទាំងស្រុង។ ប៉ុន្តែនេះមិនសមនឹងដ្យាក្រាមខាងលើទេ ដោយសារប្រតិបត្តិការមានស្ថានភាពដូចគ្នាសម្រាប់ការផ្លាស់ប្តូរទាំងអស់របស់វា ហើយជារូបវន្តមិនមានទិន្នន័យត្រូវបានបង្វិលត្រឡប់មកវិញទេ។

ដើម្បី​អនុវត្ត​មុខងារ​នេះ ប្រតិបត្តិការ​ជាមួយ​នឹង​កន្លែង​រក្សាទុក​ត្រូវ​បាន​បំបែក​ជា​ច្រើន​ដោយ​ឡែក​ពី​គ្នា។ ប្រតិបត្តិការដែលជាប់គាំង (subtransaction) ស្ថានភាពដែលអាចគ្រប់គ្រងដោយឡែកពីគ្នា។

ប្រតិបត្តិការសម្ងាត់មានលេខរៀងខ្លួន (ខ្ពស់ជាងចំនួនប្រតិបត្តិការសំខាន់)។ ស្ថានភាពប្រតិបត្តិការសម្ងាត់ត្រូវបានកត់ត្រាតាមរបៀបធម្មតានៅក្នុង XACT ប៉ុន្តែស្ថានភាពចុងក្រោយអាស្រ័យលើស្ថានភាពនៃប្រតិបត្តិការចម្បង៖ ប្រសិនបើវាត្រូវបានលុបចោល នោះប្រតិបត្តិការដែលជាប់គាំងទាំងអស់ក៏ត្រូវបានលុបចោលផងដែរ។

ព័ត៌មានអំពីប្រតិបត្តិការសំបុកត្រូវបានរក្សាទុកនៅក្នុងឯកសារនៅក្នុងថតឯកសារ PGDATA/pg_subtrans ។ ឯកសារត្រូវបានចូលប្រើតាមរយៈសតិបណ្ដោះអាសន្ននៅក្នុងអង្គចងចាំដែលបានចែករំលែករបស់វត្ថុ ដែលត្រូវបានរៀបចំតាមរបៀបដូចគ្នានឹងសតិបណ្ដោះអាសន្ន XACT ដែរ។

កុំច្រឡំប្រតិបត្តិការសម្ងាត់ជាមួយប្រតិបត្តិការស្វយ័ត។ ប្រតិបត្តិការស្វយ័តមិនអាស្រ័យលើគ្នាទៅវិញទៅមកតាមមធ្យោបាយណាមួយឡើយ ប៉ុន្តែប្រតិបត្តិការដែលលាក់ទុក។ មិនមានប្រតិបត្តិការស្វយ័តនៅក្នុង PostgreSQL ធម្មតាទេ ហើយប្រហែលជាល្អបំផុត៖ ពួកគេត្រូវការជាចាំបាច់ណាស់ កម្រណាស់ ហើយវត្តមានរបស់ពួកគេនៅក្នុង DBMSs ផ្សេងទៀតបង្កឱ្យមានការរំលោភបំពាន ដែលមនុស្សគ្រប់គ្នាទទួលរងការឈឺចាប់។

តោះលុបតារាង ចាប់ផ្តើមប្រតិបត្តិការ ហើយបញ្ចូលជួរដេក៖

=> TRUNCATE TABLE t;
=> BEGIN;
=> INSERT INTO t(s) VALUES ('FOO');
=> SELECT txid_current();

 txid_current 
--------------
         3669
(1 row)

=> SELECT xmin, xmax, * FROM t;

 xmin | xmax | id |  s  
------+------+----+-----
 3669 |    0 |  2 | FOO
(1 row)

=> SELECT * FROM heap_page('t',0);

 ctid  | state  | xmin | xmax  | t_ctid 
-------+--------+------+-------+--------
 (0,1) | normal | 3669 | 0 (a) | (0,1)
(1 row)

ឥឡូវ​យើង​ដាក់​ចំណុច​រក្សា​ទុក ហើយ​បញ្ចូល​បន្ទាត់​មួយ​ទៀត។

=> SAVEPOINT sp;
=> INSERT INTO t(s) VALUES ('XYZ');
=> SELECT txid_current();

 txid_current 
--------------
         3669
(1 row)

ចំណាំថាអនុគមន៍ txid_current() ត្រឡប់លេខប្រតិបត្តិការសំខាន់ មិនមែនលេខប្រតិបត្តិការដែលបានដាក់ជាប់នោះទេ។

=> SELECT xmin, xmax, * FROM t;

 xmin | xmax | id |  s  
------+------+----+-----
 3669 |    0 |  2 | FOO
 3670 |    0 |  3 | XYZ
(2 rows)

=> SELECT * FROM heap_page('t',0);

 ctid  | state  | xmin | xmax  | t_ctid 
-------+--------+------+-------+--------
 (0,1) | normal | 3669 | 0 (a) | (0,1)
 (0,2) | normal | 3670 | 0 (a) | (0,2)
(2 rows)

ចូរយើងវិលត្រលប់ទៅចំណុចរក្សាទុក ហើយបញ្ចូលបន្ទាត់ទីបី។

=> ROLLBACK TO sp;
=> INSERT INTO t(s) VALUES ('BAR');
=> SELECT xmin, xmax, * FROM t;

 xmin | xmax | id |  s  
------+------+----+-----
 3669 |    0 |  2 | FOO
 3671 |    0 |  4 | BAR
(2 rows)

=> SELECT * FROM heap_page('t',0);

 ctid  | state  |   xmin   | xmax  | t_ctid 
-------+--------+----------+-------+--------
 (0,1) | normal | 3669     | 0 (a) | (0,1)
 (0,2) | normal | 3670 (a) | 0 (a) | (0,2)
 (0,3) | normal | 3671     | 0 (a) | (0,3)
(3 rows)

នៅក្នុងទំព័រយើងបន្តឃើញជួរដេកដែលបានបន្ថែមដោយប្រតិបត្តិការដែលបានលុបចោល។

យើងជួសជុលការផ្លាស់ប្តូរ។

=> COMMIT;
=> SELECT xmin, xmax, * FROM t;

 xmin | xmax | id |  s  
------+------+----+-----
 3669 |    0 |  2 | FOO
 3671 |    0 |  4 | BAR
(2 rows)

=> SELECT * FROM heap_page('t',0);

 ctid  | state  |   xmin   | xmax  | t_ctid 
-------+--------+----------+-------+--------
 (0,1) | normal | 3669 (c) | 0 (a) | (0,1)
 (0,2) | normal | 3670 (a) | 0 (a) | (0,2)
 (0,3) | normal | 3671 (c) | 0 (a) | (0,3)
(3 rows)

ឥឡូវ​នេះ អ្នក​អាច​មើល​ឃើញ​យ៉ាង​ច្បាស់​ថា​ប្រតិបត្តិការ​ដែល​ជាប់​គ្នា​មាន​ស្ថានភាព​ផ្ទាល់​ខ្លួន។

ចំណាំថាប្រតិបត្តិការដែលបានដាក់ជាប់គ្នាមិនអាចត្រូវបានប្រើប្រាស់យ៉ាងច្បាស់នៅក្នុង SQL នោះទេ ពោលគឺអ្នកមិនអាចចាប់ផ្តើមប្រតិបត្តិការថ្មីដោយមិនបំពេញប្រតិបត្តិការបច្ចុប្បន្នបានទេ។ យន្តការនេះត្រូវបានធ្វើឱ្យសកម្មដោយប្រយោលនៅពេលប្រើចំណុចរក្សាទុក ក៏ដូចជានៅពេលដោះស្រាយការលើកលែង PL/pgSQL និងនៅក្នុងករណីកម្រនិងអសកម្មជាច្រើនទៀត។

=> BEGIN;

BEGIN

=> BEGIN;

WARNING:  there is already a transaction in progress
BEGIN

=> COMMIT;

COMMIT

=> COMMIT;

WARNING:  there is no transaction in progress
COMMIT

កំហុសនិងអាតូមិចនៃប្រតិបត្តិការ

តើមានអ្វីកើតឡើងប្រសិនបើកំហុសកើតឡើងនៅពេលដំណើរការប្រតិបត្តិការ? ឧទាហរណ៍ដូចនេះ៖

=> BEGIN;
=> SELECT * FROM t;

 id |  s  
----+-----
  2 | FOO
  4 | BAR
(2 rows)

=> UPDATE t SET s = repeat('X', 1/(id-4));

ERROR:  division by zero

កំហុសមួយបានកើតឡើង។ ឥឡូវនេះប្រតិបត្តិការត្រូវបានចាត់ទុកថាត្រូវបានលុបចោល ហើយមិនមានប្រតិបត្តិការណាមួយត្រូវបានអនុញ្ញាតនៅក្នុងវាទេ៖

=> SELECT * FROM t;

ERROR:  current transaction is aborted, commands ignored until end of transaction block

ហើយទោះបីជាអ្នកព្យាយាមធ្វើការផ្លាស់ប្តូរក៏ដោយ PostgreSQL នឹងរាយការណ៍អំពីការបោះបង់៖

=> COMMIT;

ROLLBACK

ហេតុអ្វីបានជាប្រតិបត្តិការមិនអាចបន្តបន្ទាប់ពីបរាជ័យ? ការពិតគឺថាកំហុសអាចកើតឡើងតាមរបៀបដែលយើងអាចចូលទៅផ្នែកនៃការផ្លាស់ប្តូរ - អាតូមិចនៃសូម្បីតែប្រតិបត្តិការក៏ដោយ ប៉ុន្តែប្រតិបត្តិករនឹងត្រូវបានបំពាន។ ដូចក្នុងឧទាហរណ៍របស់យើង ដែលប្រតិបត្តិករបានគ្រប់គ្រងដើម្បីធ្វើបច្ចុប្បន្នភាពមួយជួរមុនពេលមានកំហុស៖

=> SELECT * FROM heap_page('t',0);

 ctid  | state  |   xmin   | xmax  | t_ctid 
-------+--------+----------+-------+--------
 (0,1) | normal | 3669 (c) | 3672  | (0,4)
 (0,2) | normal | 3670 (a) | 0 (a) | (0,2)
 (0,3) | normal | 3671 (c) | 0 (a) | (0,3)
 (0,4) | normal | 3672     | 0 (a) | (0,4)
(4 rows)

វាត្រូវតែនិយាយថា psql មានរបៀបមួយដែលនៅតែអនុញ្ញាតឱ្យប្រតិបត្តិការបន្តបន្ទាប់ពីការបរាជ័យដូចជាសកម្មភាពរបស់ប្រតិបត្តិករដែលមានកំហុសត្រូវបានបង្វិលត្រឡប់មកវិញ។

=> set ON_ERROR_ROLLBACK on
=> BEGIN;
=> SELECT * FROM t;

 id |  s  
----+-----
  2 | FOO
  4 | BAR
(2 rows)

=> UPDATE t SET s = repeat('X', 1/(id-4));

ERROR:  division by zero

=> SELECT * FROM t;

 id |  s  
----+-----
  2 | FOO
  4 | BAR
(2 rows)

=> COMMIT;

វាមិនពិបាកក្នុងការស្មានទេថានៅក្នុងរបៀបនេះ psql ពិតជាដាក់ចំនុចរក្សាទុកដោយប្រយោលនៅចំពោះមុខពាក្យបញ្ជានីមួយៗ ហើយក្នុងករណីមានការបរាជ័យចាប់ផ្តើមការវិលត្រឡប់មកវិញ។ របៀបនេះមិនត្រូវបានប្រើតាមលំនាំដើមទេ ចាប់តាំងពីការកំណត់ចំណុចរក្សាទុក (សូម្បីតែមិនវិលត្រលប់ទៅរកពួកវា) ពាក់ព័ន្ធនឹងការចំណាយលើស។

ការបន្ត។

ប្រភព: www.habr.com