ასე რომ, ჩვენ განვიხილეთ საკითხები იზოლაცია, და უკან დაიხია დაახლოებით მონაცემთა დაბალ დონეზე ორგანიზება. და ბოლოს მივედით ყველაზე საინტერესო ნაწილამდე - სიმებიანი ვერსიები.

სათაური

როგორც უკვე ვთქვით, თითოეული მწკრივი შეიძლება ერთდროულად რამდენიმე ვერსიაში არსებობდეს მონაცემთა ბაზაში. ერთი ვერსია როგორმე უნდა განვასხვავოთ მეორისგან, ამ მიზნით თითოეულ ვერსიას აქვს ორი ნიშანი, რომელიც განსაზღვრავს ამ ვერსიის მოქმედების „დროს“ (xmin და xmax). ბრჭყალებში - იმიტომ, რომ გამოიყენება არა დრო, როგორც ასეთი, არამედ სპეციალური მზარდი მრიცხველი. და ეს მრიცხველი არის გარიგების ნომერი.

(ჩვეულებისამებრ, რეალობა უფრო რთულია: ტრანზაქციის ნომერი მუდმივად ვერ გაიზარდება მრიცხველის შეზღუდული ბიტის სიმძლავრის გამო. მაგრამ ამ დეტალებს დეტალურად განვიხილავთ, როდესაც გაყინვას მივიღებთ.)

როდესაც სტრიქონი იქმნება, xmin დაყენებულია ტრანზაქციის ნომერზე, რომელმაც გასცა INSERT ბრძანება და xmax რჩება ცარიელი.

როდესაც მწკრივი წაიშლება, მიმდინარე ვერსიის xmax მნიშვნელობა აღინიშნება ტრანზაქციის ნომრით, რომელმაც შეასრულა DELETE.

როდესაც მწკრივი იცვლება UPDATE ბრძანებით, რეალურად შესრულებულია ორი ოპერაცია: DELETE და INSERT. რიგის მიმდინარე ვერსია ადგენს xmax ტრანზაქციის რაოდენობის ტოლს, რომელმაც განახლდა. შემდეგ იქმნება იგივე სტრიქონის ახალი ვერსია; მისი xmin მნიშვნელობა ემთხვევა წინა ვერსიის xmax მნიშვნელობას.

xmin და xmax ველები შედის მწკრივის ვერსიის სათაურში. ამ ველების გარდა, სათაური შეიცავს სხვა ველებს, მაგალითად:

• infomask არის ბიტების სერია, რომელიც განსაზღვრავს ამ ვერსიის თვისებებს. ისინი საკმაოდ ბევრია; ჩვენ თანდათან განვიხილავთ მთავარებს.
• ctid არის ბმული იმავე ხაზის შემდეგი, უფრო ახალი ვერსიისკენ. სტრიქონის უახლესი, უახლესი ვერსიისთვის ctid ეხება თავად ამ ვერსიას. რიცხვს აქვს ფორმა (x,y), სადაც x არის გვერდის ნომერი, y არის ინდექსის ნომერი მასივში.
• null bitmap - აღნიშნავს მოცემული ვერსიის იმ სვეტებს, რომლებიც შეიცავს null მნიშვნელობას (NULL). NULL არ არის მონაცემთა ტიპის ერთ-ერთი ნორმალური მნიშვნელობა, ამიტომ ატრიბუტი ცალკე უნდა იყოს შენახული.

შედეგად, სათაური საკმაოდ დიდია - მინიმუმ 23 ბაიტი ხაზის თითოეული ვერსიისთვის და ჩვეულებრივ მეტი NULL ბიტმაპის გამო. თუ ცხრილი "ვიწროა" (ანუ შეიცავს რამდენიმე სვეტს), ზედნადებმა შეიძლება მეტი დაიჭიროს, ვიდრე სასარგებლო ინფორმაცია.

ჩადეთ

მოდით უფრო დეტალურად განვიხილოთ, თუ როგორ ხორციელდება დაბალი დონის სიმებიანი ოპერაციები, დაწყებული ჩასმა.

ექსპერიმენტებისთვის შევქმნათ ახალი ცხრილი ორი სვეტით და ინდექსით ერთ-ერთ მათგანზე:

=> 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)

მოდით შევხედოთ გვერდის შინაარსს. pageinspect გაფართოების heap_page_items ფუნქცია საშუალებას გაძლევთ მიიღოთ ინფორმაცია მაჩვენებლებისა და მწკრივების ვერსიების შესახებ:

=> 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-ში ეხება ცხრილებს. ეს არის ტერმინის კიდევ ერთი უცნაური გამოყენება - გროვა ცნობილია მონაცემთა სტრუქტურა, რომელსაც არაფერი აქვს საერთო მაგიდასთან. აქ სიტყვა გამოიყენება "ყველაფერი ერთად გადაყრილი" მნიშვნელობით, მოწესრიგებული ინდექსებისგან განსხვავებით.

ფუნქცია აჩვენებს მონაცემებს „როგორც არის“, რთულად გასაგებ ფორმატში. ამის გასარკვევად, ჩვენ დავტოვებთ ინფორმაციის მხოლოდ ნაწილს და გავშიფრავთ:

=> 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 ბიტი არ არის დაყენებული.

რიგის ვერსიის ctid ველი ეხება იმავე რიგს. ეს ნიშნავს, რომ ახალი ვერსია არ არსებობს.

xmax ველი ივსება მოჩვენებითი ნომრით 0, რადგან მწკრივის ეს ვერსია არ არის წაშლილი და აქტუალურია. ტრანზაქციები ყურადღებას არ მიაქცევს ამ რიცხვს, რადგან xmax_aborted ბიტი დაყენებულია.

მოდით გადავდგათ კიდევ ერთი ნაბიჯი წაკითხვის გასაუმჯობესებლად ტრანზაქციის ნომრებზე ინფორმაციის ბიტების დამატებით. და მოდით შევქმნათ ფუნქცია, რადგან მოთხოვნა არაერთხელ დაგვჭირდება:

=> 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)

მსგავსი, მაგრამ მნიშვნელოვნად ნაკლებად დეტალური ინფორმაციის მიღება შესაძლებელია ცხრილიდან, ფსევდო-სვეტების გამოყენებით xmin და xmax:

=> SELECT xmin, xmax, * FROM t;

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

ფიქსაცია

თუ ტრანზაქცია წარმატებით დასრულდა, თქვენ უნდა გახსოვდეთ მისი სტატუსი - გაითვალისწინეთ, რომ ის დასრულებულია. ამისათვის გამოიყენება სტრუქტურა სახელწოდებით XACT (და მე-10 ვერსიამდე მას ერქვა CLOG (კომიტაციის ჟურნალი) და ეს სახელი კვლავ შეგიძლიათ იპოვოთ სხვადასხვა ადგილას).

XACT არ არის სისტემის კატალოგის ცხრილი; ეს არის ფაილები PGDATA/pg_xact დირექტორიაში. მათ აქვთ ორი ბიტი გამოყოფილი თითოეული ტრანზაქციისთვის: ჩადენილი და შეწყვეტილი - ისევე, როგორც მწკრივის ვერსიის სათაურში. ეს ინფორმაცია დაყოფილია რამდენიმე ფაილად მხოლოდ მოხერხებულობისთვის; ჩვენ დავუბრუნდებით ამ საკითხს, როდესაც განვიხილავთ გაყინვას. და ამ ფაილებთან მუშაობა ხორციელდება გვერდიდან გვერდზე, ისევე როგორც ყველა სხვასთან.

ასე რომ, როდესაც ტრანზაქცია ჩადენილია XACT-ში, ჩადენილი ბიტი დაყენებულია ამ ტრანზაქციისთვის. და ეს არის ყველაფერი, რაც ხდება ჩადენის დროს (თუმცა ჯერ არ ვსაუბრობთ წინასწარ ჩაწერის ჟურნალზე).

როდესაც სხვა ტრანზაქცია წვდება ცხრილის გვერდს, რომელსაც ახლახან შევხედეთ, მას მოუწევს რამდენიმე კითხვაზე პასუხის გაცემა.

1. დასრულდა xmin ტრანზაქცია? თუ არა, მაშინ სტრიქონის შექმნილი ვერსია არ უნდა იყოს ხილული.
   ეს შემოწმება ხორციელდება სხვა სტრუქტურის დათვალიერებით, რომელიც მდებარეობს ინსტანციის საერთო მეხსიერებაში და ეწოდება ProcArray. იგი შეიცავს ყველა აქტიური პროცესის ჩამონათვალს და თითოეულზე მითითებულია მისი მიმდინარე (აქტიური) ტრანზაქციის ნომერი.
2. თუ დასრულებულია, მაშინ როგორ - ჩადენით ან გაუქმებით? თუ გაუქმდა, მაშინ მწკრივის ვერსიაც არ უნდა იყოს ხილული.
   ეს არის ზუსტად ის, რისთვისაც არის XACT. მაგრამ, მიუხედავად იმისა, რომ XACT-ის ბოლო გვერდები ინახება RAM-ის ბუფერებში, მაინც ძვირია XACT-ის ყოველ ჯერზე შემოწმება. მაშასადამე, ტრანზაქციის სტატუსის დადგენის შემდეგ, იგი იწერება სტრიქონის ვერსიის xmin_committed და xmin_aborted ბიტებზე. თუ ამ ბიტიდან ერთ-ერთი დაყენებულია, მაშინ 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 ბიტი წაიშლება.

გაითვალისწინეთ, რომ 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 ბიტი გასუფთავებულია, რადგან მიმდინარე ტრანზაქციის სტატუსი ჯერ არ არის ცნობილი.

ხაზის პირველი ვერსია ახლა მოიხსენიებს მეორეს (t_ctid ველს), როგორც უფრო ახალს.

მეორე ინდექსი გამოჩნდება ინდექსის გვერდზე და მეორე რიგი მიუთითებს მეორე ვერსიაზე ცხრილის გვერდზე.

ისევე, როგორც წაშლის შემთხვევაში, მწკრივის პირველ ვერსიაში xmax მნიშვნელობა მიუთითებს, რომ მწკრივი დაბლოკილია.

აბა, დავასრულოთ გარიგება.

=> COMMIT;

ინდექსები

აქამდე მხოლოდ ცხრილის გვერდებზე ვისაუბრეთ. რა ხდება ინდექსების შიგნით?

ინდექსის გვერდებზე ინფორმაცია მნიშვნელოვნად განსხვავდება ინდექსის კონკრეტული ტიპის მიხედვით. და თუნდაც ერთი ტიპის ინდექსს აქვს სხვადასხვა ტიპის გვერდები. მაგალითად, B-ხეს აქვს მეტამონაცემების გვერდი და „ჩვეულებრივი“ გვერდები.

თუმცა, გვერდს ჩვეულებრივ აქვს მწკრივებისა და თავად რიგების მაჩვენებლების მასივი (ისევე, როგორც ცხრილის გვერდი). გარდა ამისა, გვერდის ბოლოს არის ადგილი სპეციალური მონაცემებისთვის.

ინდექსებში მწკრივებს ასევე შეიძლება ჰქონდეთ ძალიან განსხვავებული სტრუქტურა, რაც დამოკიდებულია ინდექსის ტიპზე. მაგალითად, 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-ს. ნომერი შედგება პროცესის ID და რიგითი ნომრისგან.

ამ ნომრის გაცემა არ საჭიროებს სინქრონიზაციას ყველა პროცესს შორის და, შესაბამისად, ძალიან სწრაფია. ვირტუალური ნომრების გამოყენების კიდევ ერთ მიზეზს გაყინვაზე საუბრისას გავეცნობით.

ვირტუალური ნომრები არანაირად არ არის გათვალისწინებული მონაცემთა სნეპშოტებში.

დროის სხვადასხვა მომენტში, სისტემაში შეიძლება იყოს ვირტუალური ტრანზაქციები უკვე გამოყენებული ნომრებით და ეს ნორმალურია. მაგრამ ასეთი რიცხვი არ შეიძლება ჩაიწეროს მონაცემთა გვერდებზე, რადგან მომდევნო გვერდზე წვდომისას მან შეიძლება დაკარგოს მთელი მნიშვნელობა.

=> 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), რომელიც საშუალებას გაძლევთ გააუქმოთ ტრანზაქციის ნაწილი მისი სრული შეწყვეტის გარეშე. მაგრამ ეს არ ჯდება ზემოთ მოცემულ დიაგრამაში, რადგან ტრანზაქციას აქვს იგივე სტატუსი მისი ყველა ცვლილებისთვის და ფიზიკურად არცერთი მონაცემი არ არის დაბრუნებული.

ამ ფუნქციის განსახორციელებლად, შენახვის წერტილით გარიგება იყოფა რამდენიმე ცალკე წყობილი ტრანზაქციები (ქვეტრანზაქცია), რომლის სტატუსის მართვა შესაძლებელია ცალკე.

ჩადგმულ ტრანზაქციებს აქვს საკუთარი ნომერი (მთავარი ტრანზაქციის რიცხვზე მეტი). ჩადგმული ტრანზაქციის სტატუსი ჩაწერილია ჩვეული წესით XACT-ში, მაგრამ საბოლოო სტატუსი დამოკიდებულია ძირითადი ტრანზაქციის სტატუსზე: თუ ის გაუქმებულია, მაშინ ყველა ჩასმული ტრანზაქციაც გაუქმდება.

ინფორმაცია ტრანზაქციის ბუდეების შესახებ ინახება ფაილებში PGDATA/pg_subtrans დირექტორიაში. ფაილებზე წვდომა ხდება ინსტანციის საერთო მეხსიერების ბუფერების მეშვეობით, რომლებიც ორგანიზებულია ისევე, როგორც XACT ბუფერები.

არ აურიოთ ჩადგმული ტრანზაქციები ავტონომიურ ტრანზაქციებში. ავტონომიური ტრანზაქციები არანაირად არ არის დამოკიდებული ერთმანეთზე, მაგრამ წყობილი ტრანზაქციებია. რეგულარულ PostgreSQL-ში არ არსებობს ავტონომიური ტრანზაქციები და, ალბათ, საუკეთესოდ: ისინი საჭიროა ძალიან, ძალიან იშვიათად და მათი ყოფნა სხვა DBMS-ებში იწვევს შეურაცხყოფას, რის გამოც შემდეგ ყველა განიცდის.

გავასუფთავოთ ცხრილი, დავიწყოთ ტრანზაქცია და ჩავსვათ მწკრივი:

=> 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