Postgresql commit: Postgres Pro Standard : Документация: 10: COMMIT : Компания Postgres Professional

Содержание

COMMIT текущая транзакция COMMIT фиксирует текущую транзакцию.

Команда COMMIT соответствует стандарту SQL.Форма COMMIT TRANSACTION является расширением PostgreSQL.

Команда COMMIT-это транзакционная команда,используемая для сохранения изменений,вызванных транзакцией,в базе данных.Команда COMMIT сохраняет все транзакции в базе данных с момента последней команды COMMIT или ROLLBACK.

COMMIT-это команда SQL,которая используется для сохранения изменений,выполненных транзакцией.При выполнении команды COMMIT сохраняются все изменения с момента последнего COMMIT или ROLLBACK.

Команда «commit» используется для сохранения ваших изменений в локальном репозитории. Обратите внимание, что вы должны явно указать Git, какие изменения вы хотите включить в фиксацию, прежде чем запускать команду «git commit». Это означает, что файл не будет автоматически включен в следующую фиксацию только потому, что он был изменен.

Нажмите на значок Commit,чтобы зафиксировать транзакцию.Щелкните значок Rollback (Откат)для отката транзакции.Используйте опции в раскрывающемся меню Очистить,чтобы стереть содержимое экрана:Выберите Очистить окно запросов,чтобы стереть содержимое панели редактора SQL.

Чтобы зафиксировать изменения на сервере,выберите кнопку Сохранить на панели инструментов.Изменения в строке записываются на сервер автоматически при выборе другой строки.Чтобы добавить новый столбец(ы)в сетку сортировки данных,нажмите на значок [+].Используйте выпадающий столбец для выбора столбца,который вы хотите отсортировать.

Откат транзакции после ее фиксации невозможен.Вам придется восстанавливать данные из резервных копий или использовать восстановление по точке во времени,которое должно быть настроено до того,как произошла авария.

COMMIT-зафиксировать текущую транзакцию

Synopsis

COMMIT [ WORK | TRANSACTION ] [ AND [ NO ] CHAIN ]

Description

COMMIT фиксирует текущую транзакцию. Все изменения, внесенные в транзакцию, становятся видимыми для других и гарантированно сохранятся в случае сбоя.

Parameters

WORKTRANSACTION: Необязательные ключевые слова.Они не имеют никакого эффекта.
AND CHAIN: Если указано AND CHAIN , немедленно запускается новая транзакция с теми же характеристиками транзакции (см. SET TRANSACTION ), что и только что завершенная. В противном случае новая транзакция не запускается.

Notes

Используйте ROLLBACK, чтобы прервать транзакцию.

Выполнение COMMIT вне транзакции не повредит, но вызовет предупреждающее сообщение. COMMIT AND CHAIN вне транзакции является ошибкой.

Examples

Совершить текущую транзакцию и сделать все изменения постоянными:

COMMIT;

Compatibility

Команда COMMIT соответствует стандарту SQL. Форма COMMIT TRANSACTION — это расширение PostgreSQL.

Транзакции Postgres в Python, методы autocommit, rollback и уровни изоляции

В этом материале рассмотрим, как управлять транзакциями PostgreSQL из Python с помощью psycopg2. Транзакция — это единица работы (unit of work), затрагивающая набор операций базы данных.

Подготовка

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

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

Вот о чем дальше пойдет речь:

Включение и выключение режима автокомита (автосохранения).
Транзакции для сохранения изменений в базе данных.
Поддержка свойства ACID транзакции.
Откат всех операций в случае неудачи.
Изменение уровня изоляции транзакции PostgreSQL из Python.

Управление транзакциями psycopg2

Транзакции PostgreSQL обрабатываются объектом соединения. Он отвечает за сохранение изменений или откат в случае неудачи.

С помощью объекта cursor выполняются операции в базе данных. Можно создать неограниченное количество объектов cursor из объекта connection. Если любая из команд объекта cursor завершается неудачно, или же транзакция отменяется, то следующие команды не выполняются вплоть до вызова метода connection.rollback().

Объект соединения отвечает за остановку транзакции. Это можно сделать с помощью методов commit() ли rollback().
После использования метода commit() изменения сохраняются в базе данных.
С помощью метода rollback() можно откатить изменения.

Примечание: вызов метода closе() или любого другого, отвечающего за уничтожение объекта соединения, приводит к неявному вызову rollback(), вследствие чего все изменения откатываются.

Connection.autocommit

По умолчанию соединение работает в режиме автоматического сохранения, то есть свойство auto-commit равно True. Это значит, что при успешном выполнении запроса изменения немедленно сохраняются в базу данных, а откат становится невозможным.

Для выполнения запросов в транзакции это свойство нужно отключить. Для этого нужно сделать connection.autocommit=False. В этом случае будет возможность откатить выполненный запрос к оригинальному состоянию в случае неудачи.

Синтаксис autocommit:

connection.autocommit=True or Falseс

Connection.commit

Если все операции в транзакции завершены, используйте connection.commit() для сохранения изменений в базе данных. Если метод не использовать, то все эффекты взаимодействия с данными не будут применены.

Синтаксис commit:

connection.commit()

Connection.rollback

Если в транзакции хотя бы одна операция завершается неудачно, то отменить изменения можно с помощью connection.rollback().

Синтаксис rollback:

connection. rollback()

Пример управления транзакциями PostgreSQL из Python

Отключите режим автосохранения (auto-commit).
Если все операции были выполнены успешно, используйте connection.commit() для их сохранения в базе данных.
Если какая-то из операций была завершена неудачно, то откатиться к последнему состоянию можно с помощью connection.rollback().

Примечание: транзакция остается открытой до явного вызова commit() или rollback().

Давайте понизим цену на один телефон и повысим на второй.

Копировать Скопировано Use a different Browser

import psycopg2
from psycopg2 import Error
try:
    # Подключиться к существующей базе данных
    connection = psycopg2.connect(user="postgres",
                                  # пароль, который указали при установке PostgreSQL
                                  password="1111",
                                  host="127.  0.0.1",
                                  port="5432",
                                  database="postgres_db")
    connection.autocommit=False
    cursor = connection.cursor()
    amount = 200
    query = """select price from mobile where id = 1"""
    cursor.execute(query)
    record = cursor.fetchone() [0]
    price_a  = int(record)
    price_a -= amount
    # Понизить цену у первого
    sql_update_query = """update mobile set price = %s where id = 1"""
    cursor.execute(sql_update_query,(price_a,))
    query = """select price from mobile where id = 2"""
    cursor.execute(query)
    record = cursor.fetchone() [0]
    price_b = int(record)
    price_b += amount
    # Повысить цену у второго
    sql_update_query = """Update mobile set price = %s where id = 2"""
    cursor.execute(sql_update_query, (price_b,))
    # совершение транзакции
    connection.commit()
    print("Транзакция успешно завершена")
except (Exception, psycopg2.DatabaseError) as error :
    print ("Ошибка в транзакции.
  Отмена всех остальных операций транзакции", error)
    connection.rollback()
finally:
    if connection:
        cursor.close()
        connection.close()
        print("Соединение с PostgreSQL закрыто")

Вы получите следующий вывод после успешного завершения всех операций в транзакции.

Транзакция успешно завершена
Соединение с PostgreSQL закрыто

Если хотя бы одна из операций будет завершена с ошибкой, то вывод будет таким.

Ошибка в транзакции. Отмена всех остальных операций транзакции
Соединение с PostgreSQL закрыто

Инструкция With для управления транзакциями

Для создания транзакции внутри определенного блока в коде используйте инструкцию with.

Что делает инструкция with

?Соединения и объекта cursor в psycopg2 — это всего лишь контекстные менеджеры, которые можно использовать с with. Основное преимущество в том, что это позволяет не писать явно commit или rollback.

Синтаксис:

Копировать Скопировано Use a different Browser

with psycopg2.connect(connection_arguments) as conn:
    with conn.cursor() as cursor:
        cursor.execute(Query)

Когда соединение выходит из блока with, а запрос выполняется без ошибок или исключений, транзакция сохраняется. Если же в процессе возникла проблема, то транзакция откатывается.

При выходе за пределы блока соединение не закрывается, но объекты cursor и любые другие связанные объекты — да. Соединение можно использовать в более чем одном with, и каждый блок

with — это всего лишь транзакция.

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

Копировать Скопировано Use a different Browser

import psycopg2
from psycopg2 import Error
   connection = psycopg2.connect(**params)
   with connection:
       with connection. cursor() as cursor:
           # Поиск цены товара
           query = """select price from itemstable where itemid = 876"""
           cursor.execute(query)
           record = cursor.fetchone() [0]
           item_price = int(record)
           # Получение остатка на счету
           query = """select balance from ewallet where userId = 23"""
           cursor.execute(query)
           record = cursor.fetchone() [0]
           ewallet_balance  = int(record)
           new_ewallet_balance -= item_price
           
           # Обновление баланса с учетом расхода
           sql_update_query = """Update ewallet set balance = %s where id = 23"""
           cursor.execute(sql_update_query,(new_ewallet_balance,))
           
           # Зачисление на баланс компании
           query = """select balance from account where accountId = 2236781258763"""
           cursor.execute(query)
           record = cursor.fetchone()
           account_balance  = int(record)
           new_account_balance += item_price
           # Обновление счета компании
           sql_update_query = """Update account set balance = %s where id = 132456"""
           cursor.  execute(sql_update_query, (new_account_balance,))
           print("Транзакция успешно завершена")

Уровни изоляции psycopg2

В системах баз данных с помощью уровней изоляции можно определить какой уровень целостности транзакции будет виден остальным пользователям и системам.

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

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

psycopg2.extensions предоставляет следующие уровня изоляции:

psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT,
psycopg2.extensions.ISOLATION_LEVEL_READ_UNCOMMITTED,
psycopg2.extensions.ISOLATION_LEVEL_READ_COMMITTED,
psycopg2.extensions.ISOLATION_LEVEL_REPEATABLE_READ,
psycopg2.extensions.ISOLATION_LEVEL_SERIALIZABLE,
psycopg2.extensions.ISOLATION_LEVEL_DEFAULT.

Как задать уровни изоляции

Это можно сделать с помощью класса connection:

conn.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)

Также можно использовать метод connection.set_session.

connectio.set_session(isolation_level=None, readonly=None, deferrable=None, autocommit=None)

В этом случае isolation_level могут быть READ UNCOMMITED, REPEATABLE READ, SERIALIZE или другие из списка констант.

Использование транзакций | Вставка и изменение данных

СОДЕРЖАНИЕ

Введение
Что такое транзакции?
Типы сбоев согласованности
Уровни выделения транзакций
Определение транзакции
Обработанные транзакции
с использованием точек сохранения при отказе
Установка уровня выделения транзакций
Цепные транзакции
Заключение

.

Введение

0003

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

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

Что такое транзакции?

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

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

Эти функции помогают базам данных достичь соответствия ACID, обеспечивая атомарность (все действия в транзакции либо фиксируются, либо все откатываются) и изоляцию (вне транзакции ничего не меняется до фиксации, а внутри инструкции имеют последствия). Вместе они помогают базе данных поддерживать согласованность (гарантируя невозможность частичного преобразования данных). Кроме того, изменения в транзакциях не возвращаются как успешные, пока они не будут зафиксированы в энергонезависимом хранилище, что обеспечивает надежность.

Для достижения этих целей в транзакциях используется ряд различных стратегий, а в разных системах баз данных используются разные методы. PostgreSQL использует систему под названием Multiversion Concurrency Control (MVCC), которая позволяет базе данных выполнять эти действия без ненужной блокировки с помощью моментальных снимков данных. Все вместе эти системы составляют один из фундаментальных строительных блоков современных реляционных баз данных, позволяя им безопасно обрабатывать сложные данные без сбоев.

Типы ошибок согласованности

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

Существует четыре основных способа возникновения несогласованности в зависимости от реализации транзакции. Ваша терпимость к сценариям, в которых эти сценарии могут возникнуть, повлияет на то, как вы используете транзакции в своих приложениях.

Грязные чтения

Грязные чтения происходят, когда операторы внутри транзакции могут считывать данные, записанные другими выполняющимися транзакциями. Это означает, что даже несмотря на то, что операторы транзакции , а не еще зафиксированы, их можно прочитать и, таким образом, повлиять на другие транзакции.

Это часто считается серьезным нарушением согласованности, поскольку транзакции должным образом не изолированы друг от друга. Операторы, которые могут никогда не быть зафиксированы в базе данных, могут повлиять на выполнение других транзакций, изменяя их поведение.

Транзакции, допускающие грязное чтение, не могут предъявлять никаких разумных требований относительно согласованности результирующих данных.

Неповторяющиеся чтения

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

Как и в случае грязного чтения, транзакции, допускающие неповторяемое чтение, не обеспечивают полной изоляции между транзакциями. Разница в том, что при неповторяющихся чтениях операторы, влияющие на транзакцию, фактически были зафиксированы вне транзакции.

Фантомное чтение

Фантомное чтение — это особый тип неповторяемого чтения, который происходит, когда строки, возвращаемые запросом, отличаются во время его второго выполнения в рамках транзакции.

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

Аномалии сериализации

Аномалии сериализации возникают, когда результаты нескольких транзакций, совершенных одновременно, приводят к другим результатам, чем если бы они были зафиксированы одна за другой. Это может произойти в любое время, когда транзакция допускает две фиксации, каждая из которых изменяет одну и ту же таблицу или данные без разрешения конфликтов.

Аномалии сериализации — это особый тип проблем, о которых ранние типы транзакций не знали. Это связано с тем, что ранние транзакции были реализованы с блокировкой, когда нельзя было продолжать, если другая транзакция считывала или изменяла тот же фрагмент данных.

Уровни изоляции транзакций

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

Уровни изоляции, предлагаемые большинством систем баз данных, включают следующие:

Чтение незафиксированных

Чтение незафиксированных — это уровень изоляции, который предлагает наименьшие гарантии в отношении поддержания согласованности и изоляции данных. В то время как транзакции с использованием read uncommitted имеют определенные функции, часто связанные с транзакциями, такие как возможность одновременной фиксации нескольких операторов или отката операторов в случае возникновения ошибки, они делают допускают многочисленные ситуации, когда согласованность может быть нарушена.

Транзакции, сконфигурированные с уровнем изоляции read uncommitted , допускают:

грязные чтения
неповторяемые чтения
фантомные чтения
аномалии сериализации

Этот уровень изоляции на самом деле не реализован в PostgreSQL. Хотя PostgreSQL распознает имя уровня изоляции, внутренне оно на самом деле не поддерживается, и вместо него будет использоваться «чтение зафиксировано» (описано ниже).

Чтение зафиксировано

Чтение зафиксировано — это уровень изоляции, специально защищающий от грязного чтения. Когда транзакции используют уровень согласованности read commited , незафиксированные данные никогда не могут повлиять на внутренний контекст транзакции. Это обеспечивает базовый уровень согласованности, гарантируя, что незафиксированные данные никогда не повлияют на транзакцию.

Хотя read commited обеспечивает большую защиту, чем read uncommitted , он не защищает от всех типов несогласованности. Эти проблемы все еще могут возникать:

неповторяющиеся чтения
фантомные чтения
аномалии сериализации

PostgreSQL будет использовать уровень зафиксированное чтение по умолчанию, если не указан другой уровень изоляции.

Повторяемое чтение

Повторяемое чтение 9Уровень изоляции 0086 основывается на гарантии, предоставляемой read commited . Он, как и раньше, избегает грязных чтений, но также предотвращает неповторяющиеся чтения.

Это означает, что никакие изменения, зафиксированные вне транзакции, никогда не повлияют на данные, считанные в рамках транзакции. Запрос, выполненный в начале транзакции, никогда не будет иметь другого результата в конце транзакции, если только он не вызван операторами внутри транзакции.

В то время как стандартное разрешение 9Уровень изоляции 0087 Repeatable Read требует только предотвращения грязных и неповторяемых операций чтения, PostgreSQL также предотвращает фантомные чтения на этом уровне. Это означает, что фиксации вне транзакции не могут изменить количество строк, удовлетворяющих запросу.

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

Уровень изоляции PostgreSQL с повторяющимся чтением блокирует большинство типов проблем согласованности, но аномалии сериализации все еще могут возникать.

Serializable

Уровень изоляции Serializable обеспечивает высочайший уровень изоляции и согласованности. Это предотвращает все сценарии, которые делает уровень повторяемого чтения , а также устраняет возможность аномалий сериализации.

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

Определение транзакции

Теперь, когда мы рассмотрели различные уровни изоляции, которые PostgreSQL может использовать в транзакциях, давайте продемонстрируем, как определять транзакции.

В PostgreSQL каждый оператор за пределами явно помеченной транзакции фактически выполняется в отдельной транзакции, состоящей из одного оператора. Чтобы явно запустить блок транзакции, вы можете использовать команду BEGIN или START TRANSACTION (они являются синонимами). Чтобы совершить транзакцию, введите Команда COMMIT .

Таким образом, основной синтаксис транзакции выглядит следующим образом:

   BEGIN; 
  операторов 
  COMMIT;

В качестве более конкретного примера представьте, что мы пытаемся перевести 1000 долларов с одного счета на другой. Мы хотим, чтобы деньги всегда были на одном из двух счетов, но никогда на обоих.

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

   НАЧАЛО; 
  ОБНОВЛЕНИЕ счетов 
  УСТАНОВИТЬ баланс = баланс - 1000 
  ГДЕ id = 1; 
  ОБНОВЛЕНИЕ счетов 
  УСТАНОВИТЬ баланс = баланс + 1000 
  ГДЕ id = 2; 
  СОВЕРШИТЬ;

Здесь 1000 долларов не будут сняты со счета с id = 1 без внесения 1000 долларов на счет с id = 2 . Хотя эти два оператора выполняются последовательно 90 051 в рамках транзакции 90 052, они будут зафиксированы и, следовательно, будут выполняться на базовом наборе данных одновременно.

Откат транзакций

В рамках транзакции либо все операторы, либо ни одно из них не будут зафиксированы в базе данных. Отказ от операторов и изменений, сделанных в транзакции, вместо их применения к базе данных называется «откатом» транзакции.

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

Чтобы вручную откатить операторы, которые были даны во время текущей транзакции, вы можете использовать команду ROLLBACK . Это отменит все операторы внутри транзакции, по сути вернув время вспять к началу транзакции.

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

   НАЧАЛО; 
  ОБНОВЛЕНИЕ счетов 
  УСТАНОВИТЬ баланс = баланс - 1500 
  ГДЕ id = 1; 
  ОБНОВЛЕНИЕ счетов 
  УСТАНОВИТЬ баланс = баланс + 1500 
  ГДЕ id = 3; -- Здесь неправильный номер счета! Должен выполнить откат 
  /* Возвращает нас туда, где мы были до начала транзакции */ 
  ROLLBACK;

Как только мы ROLLBACK , 1500 долларов все еще будут на счете с id = 1 .

Использование точек сохранения при откате

По умолчанию команда ROLLBACK сбрасывает транзакцию до того состояния, в котором она была при первом вызове команд BEGIN или START TRANSACTION . Но что, если мы хотим отменить только некоторые операторы внутри транзакции?

Хотя вы не можете указать произвольные места для отката при вводе команды ROLLBACK , вы можете откатиться к любым «точкам сохранения», которые вы установили на протяжении всей транзакции. Вы можете заранее отметить места в своей транзакции с помощью SAVEPOINT , а затем ссылайтесь на эти конкретные места, когда вам нужно выполнить откат.

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

Чтобы указать точку сохранения, введите команду SAVEPOINT с указанием имени точки сохранения:

   SAVEPOINT save_1;

Чтобы вернуться к этой точке сохранения, используйте команду ROLLBACK TO :

   ROLLBACK TO save_1;

Давайте продолжим пример с учетными записями, который мы использовали:

   BEGIN; 
  ОБНОВЛЕНИЕ счетов 
  УСТАНОВИТЬ баланс = баланс - 1500 
  ГДЕ id = 1; 
  /* Установить точку сохранения, к которой мы можем вернуться */ 
  SAVEPOINT save_1; 
  ОБНОВЛЕНИЕ счетов 
  НАБОР баланса = баланс + 1500 
  ГДЕ id = 3; -- Здесь неправильный номер счета! Но мы можем вернуться к точке сохранения! 
  /* Возвращает нас к состоянию транзакции в `save_1` */ 
  ROLLBACK TO save_1; 
  /* Продолжить транзакцию с правильным номером счета */ 
  ОБНОВЛЕНИЕ счетов 
  SET balance = balance + 1500 
  WHERE id = 4; 
  СОВЕРШИТЬ;

Здесь мы можем восстановиться после допущенной нами ошибки, не теряя при этом всей работы, проделанной нами в транзакции. После отката мы продолжаем транзакцию, как и планировалось, используя правильные операторы.

Установка уровня изоляции транзакций

Чтобы установить желаемый уровень изоляции для транзакции, вы можете добавить условие ISOLATION LEVEL к вашей команде START TRANSACTION или BEGIN . Базовый синтаксис выглядит следующим образом:

   НАЧАЛЬНЫЙ УРОВЕНЬ ИЗОЛЯЦИИ ; 
  операторов 
  COMMIT;

может быть любым из этих (подробно описано ранее):

Прочтите нерешенное (приведет к читать , так как этот уровень не реализован в Postgresql)
Читать Commetted

9008 Команда также может использоваться для установки уровня изоляции после запуска транзакции. Однако вы можете использовать SET TRANSACTION только перед выполнением каких-либо запросов или команд изменения данных, поэтому это не обеспечивает повышенной гибкости. Объединение транзакций в цепочки Если у вас есть несколько транзакций, которые должны выполняться последовательно, вы можете связать их вместе с помощью команды COMMIT AND CHAIN . Команда COMMIT AND CHAIN завершает текущую транзакцию, фиксируя операторы внутри. После того, как фиксация обработана, сразу же открывается новая транзакция. Это позволяет сгруппировать другой набор операторов вместе в транзакции. Оператор работает точно так же, как если бы вы выпустили СОВЕРШИТЬ; НАЧАЛО : НАЧАЛО; ОБНОВЛЕНИЕ счетов УСТАНОВИТЬ баланс = баланс - 1500 ГДЕ id = 1; ОБНОВЛЕНИЕ счетов УСТАНОВИТЬ баланс = баланс + 1500 ГДЕ id = 2; /* Зафиксировать данные и начать новую транзакцию, в которой будут учтены данные, зафиксированные последней транзакцией */ COMMIT AND CHAIN; ОБНОВЛЕНИЕ счетов УСТАНОВИТЬ баланс = баланс - 1000 ГДЕ id = 2; ОБНОВЛЕНИЕ счетов УСТАНОВИТЬ баланс = баланс + 1000 ГДЕ id = 3; СОВЕРШИТЬ; Цепочка транзакций не предлагает многого с точки зрения новых функций, но может быть полезна для фиксации данных в естественных границах, продолжая при этом фокусироваться на операциях того же типа. Заключение Транзакции не панацея. Существует множество компромиссов, связанных с различными уровнями изоляции, и понимание того, какие типы согласованности вам необходимо защитить, может потребовать размышлений и планирования. Это особенно верно для длительных транзакций, когда базовые данные могут значительно измениться и увеличивается вероятность конфликта с другими параллельными транзакциями. При этом механика транзакций предлагает большую гибкость и мощность. Это имеет большое значение для обеспечения гарантий ACID даже при выполнении взаимосвязанных параллельных операций. Знание того, когда и как правильно использовать транзакции для выполнения сложных и безопасных операций, бесценно. Назад Импорт и экспорт данных в PostgreSQL Далее Как выполнять основные запросы с помощью `SELECT` в PostgreSQL Редактировать эту страницу на GitHub Управление транзакциями PostgreSQL в Python с использованием фиксации и отката На этом уроке вы научитесь управлять транзакциями PostgreSQL из Python с помощью psycopg2 . Транзакция — это единица работы, включающая набор операций с базой данных. В большинстве случаев мы хотим выполнять операцию с базой данных PostgreSQL только после завершения другого процесса. Например, в системе онлайн-банковских транзакций мы можем вносить деньги на счет B только со счета A только после успешного снятия. В транзакции выполняются либо все операции, либо ни одна из операций. То есть нам нужно успешно завершить все операции в рамках одной транзакции, чтобы назвать ее успешной транзакцией. В этом разделе рассматриваются следующие темы : – Включение и отключение режима автоматической фиксации. Фиксация транзакций для сохранения изменений в базе данных. Сохранение свойства ACID транзакции. Откат всех операций в случае неудачи. Изменить уровень изоляции транзакций PostgreSQL от Python. СОДЕРЖАНИЕ PSYCOPG2 Управление транзакциями AutoCommit Commit ROLLBACK СТАРИТЕЛЬНОСТЬ для управления транзакциями PostGRESQL от Python Python. Константы уровня изоляции Как установить уровни изоляции Следующие шаги: Управление транзакциями Psycopg2 Объект соединения обрабатывает транзакции PostgreSQL. Объект подключения отвечает за сохранение изменений в базе данных или их отмену в случае сбоя транзакции. Используя объект курсор , мы выполняем операции с базой данных. Мы можем создать любое количество объектов курсора из объекта подключения. Если какая-либо из команд курсора терпит неудачу или транзакция прерывается, дальнейшие команды не выполняются до вызова метод connection.rollback() . Объект подключения отвечает за завершение своей транзакции . Есть два способа сделать это, вызвав метод commit() или rollback() . Использование метода commit() изменений фиксируются и немедленно сохраняются в базе данных. Используя метод rollback() , мы можем отменить изменения в базе данных. Вызов метод close() или любое другое средство уничтожения объекта подключения приведет к неявному вызову rollback(), т. е. все изменения будут отменены. Autocommit Синтаксис AutoCommit connection.autocommit = True или False По умолчанию соединение находится в режиме автоматической фиксации. т. е. значение по умолчанию — True . Если какой-либо запрос выполняется успешно, изменения немедленно фиксируются в базе данных, и откат невозможен. Чтобы выполнять запросы внутри транзакции, нам нужно отключить автоматическую фиксацию. Используя connection.autocommit=False , мы можем отменить выполненную операцию в случае сбоя промежуточной транзакции. commit Синтаксис commit() method connection.commit() Если все операции завершены успешно, используйте connection.commit() для сохранения изменений базы данных для поддержания целостности и согласованности данных . Если commit() не вызывается, эффект от любых манипуляций с данными будет потерян. Откат Если какая-либо из операций завершается сбоем внутри выполняющейся транзакции, вы можете отменить изменения, сделанные всеми предыдущими операциями, используя connection.rollback() Синтаксис rollback() connection.rollback() Если какая-либо из операций завершается с ошибкой внутри выполняющейся транзакции, вы можете отменить изменения, сделанные всеми предыдущими операциями, с помощью соединение.откат() . Действия по управлению транзакциями PostgreSQL из Python Подключение к базе данных Отключить режим автоматической фиксации. Выполнить набор SQL-запросов один за другим Если все операции в рамках транзакции завершены успешно, используйте commit() для сохранения изменений в базе данных. Если какой-либо из запросов не выполняется, отменить изменения, сделанные всеми операциями, с помощью rollback() Примечание : Транзакция будет оставаться открытой до тех пор, пока не будет явно commit() или rollback() . Пример Python для управления транзакциями PostgreSQL import psycopg2 пытаться: соединение = psycopg2.connect(пользователь="postgres", пароль="пароль@#29", хост = "127.0.0.1", порт = "5432", база данных = "postgres_db") соединение.autocommit = Ложь курсор = соединение.курсор() сумма = 2500 query = """выберите баланс из учетной записи, где id = 624001562408""" курсор.выполнить(запрос) запись = курсор.fetchone () [0] balance_account_A = int(запись) balance_account_A -= сумма # Вывести со счета А сейчас sql_update_query = """Обновить баланс учетной записи = %s, где id = 624001562408""" cursor.execute (sql_update_query, (balance_account_A,)) query = """выберите баланс из учетной записи, где id = 2236781258763""" курсор.выполнить(запрос) запись = курсор.fetchone () [0] balance_account_B = int(запись) balance_account_B += сумма # Зачисление на счет B сейчас sql_update_query = """Обновить баланс учетной записи = %s, где id = 2236781258763""" cursor. execute (sql_update_query, (balance_account_B,)) # фиксируем обе транзакции в базе данных соединение.коммит() print("Транзакция успешно завершена") кроме (Exception, psycopg2.DatabaseError) как ошибка: print("Ошибка транзакции Откат всех остальных операций транзакции ", ошибка) соединение.откат() в конце концов: # закрытие соединения с базой данных. если подключение: курсор.закрыть() соединение.закрыть() print("Соединение с PostgreSQL закрыто") Выход Транзакция успешно завершена Соединение PostgreSQL закрыто Вы можете получить следующий вывод, если какая-либо из операций внутри транзакции не удалась. Ошибка в транзакции Отмена всех других операций транзакции Соединение PostgreSQL закрыто Если вы хотите создать транзакцию в определенном блоке кода, используйте оператор with . Если вы хотите создать транзакцию в определенном блоке кода, используйте с оператором . Соединения и курсоры Psycopg2 — не что иное, как менеджеры контекста, и их можно использовать с оператором with. Основное преимущество использования с блоком заключается в том, что вам не нужно выполнять какую-либо явную фиксацию и откат. Синтаксис : с psycopg2.connect(connection_arguments) в качестве подключения: с conn.cursor() в качестве курсора: cursor.execute(Query) Когда соединение выходит из блока с и запрос выполняется без каких-либо ошибок и исключений, транзакция автоматически фиксируется, иначе транзакция откатывается. Когда вы выходите из области действия блока с , он не закрывает соединение, но курсор и другие ресурсы, связанные с ним, закрываются. Доступно соединение для других с блоками . Каждый блок с блоком представляет собой не что иное, как отдельную транзакцию. Давайте посмотрим демонстрацию. В этом примере мы выполним транзакцию онлайн-покупки. Купите товар, вычтите остаток из кошелька клиента и добавьте его на счет компании. Мы размещаем все запросы внутри с блоком . импорт psycopg2 соединение = psycopg2.connect(пользователь="postgres", пароль="пароль@#29", хост = "127.0.0.1", порт = "5432", база данных = "postgres_db") с подключением: с connection.cursor() в качестве курсора: query = """выберите цену из таблицы товаров, где itemid = 876""" курсор.выполнить(запрос) запись = курсор.fetchone () [0] Цена товара = целое (запись) # узнать баланс электронного кошелька клиента query = """выберите баланс из электронного кошелька, где userId = 23""" курсор.выполнить(запрос) запись = курсор.fetchone () [0] ewalletBalance = int(запись) new_EwalletBalance = баланс электронного кошелька new_EwalletBalance -= Цена товара # Вывод средств из электронного кошелька сейчас sql_update_query = """Обновить баланс набора электронных кошельков = %s, где id = 23""" курсор. execute(sql_update_query, (new_EwalletBalance,)) # добавить в аккаунт компании query = """выберите баланс из учетной записи, где accountId = 2236781258763""" курсор.выполнить(запрос) запись = курсор.fetchone() accountBalance = int(запись) new_AccountBalance = баланс счета new_AccountBalance += Цена товара # Кредит на счет компании сейчас sql_update_query = """Обновить баланс учетной записи = %s, где id = 2236781258763""" cursor.execute (sql_update_query, (new_AccountBalance,)) print("Транзакция успешно завершена") Константы уровня изоляции Psycopg2 В системах баз данных. Используя уровни изоляции, мы можем определить, какой уровень целостности транзакций виден другим пользователям и системам. Подробнее об изоляции базы данных Изоляция транзакций PostgreSQL Например, когда пользователь выполняет какое-то действие или операцию, но операция еще не завершена, сведения об этой операции доступны другим пользователям для выполнения некоторых параллельных действий. Например, когда пользователь покупает некоторые товары, эти сведения об операции передаются другим пользователям системы для подготовки счетов, квитанций о товарах и расчета скидок для ускорения процесса. Если уровень изоляции низкий, многие пользователи могут получить доступ к одним и тем же данным одновременно. Но это также может привести ко многим проблемам параллелизма, таким как грязное чтение и потеря обновлений. Поэтому было бы лучше, если бы вы использовали уровень изоляции с учетом всех этих моментов. Более высокий уровень изоляции может помешать другим пользователям или транзакциям выполнить себя первыми. psycopg2.extensions предоставляет нам следующие уровни изоляции: psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT psycopg2.extensions.ISOLATION_LEVEL_READ_UNCOMMITTED psycopg2.extensions.ISOLATION_LEVEL_READ_COMMITTED psycopg2.extensions.ISOLATION_LEVEL_REPEATABLE_READ psycopg2.extensions.ISOLATION_LEVEL_SERIALIZABLE psycopg2.extensions.