Несомненно, транзакции очень хороши, но в предыдущих версиях PostgreSQL механизм транзакций следовал принципу "все, или ничего", ликвидируя транзакцию, если внутри нее произошла ошибка. К счастью, в новой версии PostgreSQL 8 эта проблема решается путем добавления "savepoints" (точек сохранения), которые позволяют откатить только часть транзакции и изящно восстановиться от ошибки.

Одна из очень хороших особенностей PostgreSQL - транзакции. Они предотвращают случайную потерю данных или их искажение.

Например, скажем, вы хотите удалить записи из таблицы. В PostgreSQL команда выглядит так:

template1=# DELETE FROM foo;

Однако данная команда удалит все записи в таблице. Может оказаться, что это совсем не то, чего вы хотели, и, если вы не использовали транзакцию, единственным способом восстановить базу будет восстановление из резервной копии. Используя транзакции, вернуть данные очень просто. Пусть выполняется следующая последовательность команд:

BEGIN;
       DELETE FROM foo;
       DELETE 50

Оператор BEGIN заставляет базу данных начать транзакцию. Как только вы поймете, что забыли включить раздел WHERE и удалили всю таблицу, вы сможете откатить транзакцию.

BEGIN;
       DELETE FROM foo;
       DELETE 50
    ROLLBACK;

Есть один недостаток в такой реализации транзакций - если внутри транзакции произошла ошибка, вы обязаны сделать откат. Откат производится при выполнении команды rollback, задаваемой внутри транзакции, и эта команда должна быть выполнена до того, как будут выполняться какие-либо другие команды в данном соединении. После выполнения отката вы должны снова запустить транзакцию и повторить команды таким образом, чтобы не совершить ошибку. Это правило включает в себя и ошибки пользователей типа удаления всех записей в таблице, и синтаксические ошибки типа попытки выбрать строки из таблицы, которая не существует. Например:

BEGIN;
       UPDATE foo SET bar = (SELECT count(*) FROM baz));
       INSERT INTO foo (column1) SELECT column2 FROM bar;
       ОШИБКА: отношение "bar" не существует
       CREATE TABLE bar (column1 text, column2 float);
       ОШИБКА:  текущая транзакция прерывается,
          команды игнорируются до конца блока транзакции

Из-за ошибки вы будете вынуждены делать откат, и вся ваша текущая работа будет потеряна. Этот специфический аспект транзакций PostgreSQL особенно раздражает в период отладки и тестирования.

Точки сохранения - путь к спасению.

В новой версии PostgreSQL 8 эта проблема решается на основе точек сохранения. Точки сохранения - это именованные метки, которые разбивают транзакцию на этапы, заставляя базу сохранять данные в рамках каждого этапа. В случае ошибки мы можем определить этап, на котором она возникла, и сделать откат только до предыдущей точки сохранения, не теряя при этом работу, которая была проделана перед точкой сохранения. Поскольку каждая точка сохранения имеет свое имя, то и обращаться к ней необходимо по ее имени.

Чтобы инициализировать точку сохранения, вы должны быть в пределах блока транзакции:

template1=# BEGIN;
    
    BEGIN
    template1=# INSERT INTO foo(column1,column2,column3) VALUES (1,2,0);
    INSERT 17231 1
    template1=# INSERT INTO foo(column1,column2,column3) VALUES (1,2,0);
    INSERT 17232 1
    template1=# INSERT INTO foo(column1,column2,column3) VALUES (1,2,0);
    INSERT 17233 1
    template1=# SELECT * FROM foo;
    column1 | column2 | column3
    ---------+--------+--------
        1 |       2 |       0
        1 |       2 |       0
        1 |       2 |       0
    (3 rows)
    
    template1=# SAVEPOINT main_values_inserted;
    SAVEPOINT
    template1=# INSERT INTO foo(column1,column2,column3) VALUES (1,2,1/0);
    ОШИБКА:  деление на ноль
    ОШИБКА:  деление на ноль

В предыдущей версии PostgreSQL вы потеряли бы результаты всех операций INSERT в этом коде (после возникновения ошибки деления на ноль в последнем операторе INSERT), но в версии 8 вы можете сделать откат до определенной точки сохранения. Обратите внимание, что код содержит точку сохранения с именем 'main_values_inserted'. Для отката до этой точки сохранения вы можете написать:

template1=# ROLLBACK TO main_values_inserted;
    ROLLBACK

Выполняя откат до этой точки сохранения, вы сохраняете все, что было сделано до нее, теряя только работу, выполненную после точки сохранения. После отката вы можете продолжить свою работу без полного повтора транзакции:

template1=# INSERT INTO foo(column1,column2,column3) VALUES (5,9,10);
    INSERT 17234 1
    template1=# INSERT INTO foo(column1,column2,column3) VALUES (5,9,10);
    INSERT 17235 1
    template1=# INSERT INTO foo(column1,column2,column3) VALUES (5,9,10);
    INSERT 17236 1
    template1=# INSERT INTO foo(column1,column2,column3) VALUES (5,9,10);
    INSERT 17237 1
    template1=# SAVEPOINT secondary_values_inserted;
    SAVEPOINT
    template1=# SELECT * FROM foo;
    column1 | column2 | column3
    ---------+--------+--------
        1 |       2 |       0
        1 |       2 |       0
        1 |       2 |       0
        5 |       9 |      10
        5 |       9 |      10
        5 |       9 |      10
        5 |       9 |      10
    (7 rows)
    template1=# SAVEPOINT all_values_inserted;
    SAVEPOINT
    template1=# DELETE FROM foo;
    DELETE 7
    template1=# SELECT * FROM foo;
    column1 | column2 | column3
    ---------+--------+--------
    (0 rows) 

Ой. Так же, как и в первом примере этой статьи, вы в действительности хотели удалить только одну строку, в которой 'column1 = 1'. Но теперь вы можете сделать откат ко второй точке сохранения 'all_values_inserted'.

template1=# ROLLBACK TO all_values_inserted;
    ROLLBACK
    template1=# SELECT * FROM foo;
    column1 | column2 | column3
    ---------+--------+--------
        1 |       2 |       0
        1 |       2 |       0
        1 |       2 |       0
        5 |       9 |      10
        5 |       9 |      10
        5 |       9 |      10
        5 |       9 |      10
    (7 rows) 

Обратите внимание, что это восстановило все ваши данные. Теперь вы можете выполнить корректный оператор удаления.

template1=# DELETE FROM foo WHERE column1 = 1;
    DELETE 3
    template1=# SELECT * FROM foo;
    column1 | column2 | column3
    ---------+--------+--------
        5 |       9 |      10
        5 |       9 |      10
        5 |       9 |      10
        5 |       9 |      10
    (4 rows) 

Наконец, вы можете зафиксировать вашу транзакцию. Последняя команда SELECT показывает, что целостность данных после всех этих вставок и откатов не нарушена.

template1=# COMMIT;
COMMIT
template1=# select * from foo;
 column1 | column2 | column3
---------+--------+--------
       5 |       9 |      10
       5 |       9 |      10
       5 |       9 |      10
       5 |       9 |      10
(4 rows) 

В PostgreSQL 8.0 имеется много новых возможностей - точки сохранения, исключительные ситуации, plPgSQL и восстановление "Point in Time". Это делает систему наиболее предпочтительной для серьезных разработчиков среди баз данных категории Open Source.

Джошуа Д. Дрейк - Президент Command Prompt, Inc. Компания занимается поддержкой PostgreSQL и разработкой заказных программных систем. Он также соавтор книги 'Practical PostgreSQL', изданной O'Reilly and Associates.