Commit transaction: COMMIT TRANSACTION (Transact-SQL) — SQL Server

Как использовать транзакции (begin transaction, commit transaction)?

Я видел использование транзакций в некоторых случаях, но никогда по-настоящему не понимал, в каких ситуациях они должны использоваться. Как и когда следует использовать транзакции (begin transaction statement)? Я читал, что Microsoft не предлагает использовать операторы транзакций (commit, rollback) внутри триггера и хранимой процедуры.

sql-server

sql-server-2005

sql-server-2008

stored-procedures

transactions

Поделиться

Источник

juur    

26 сентября 2010 в 15:59

2 ответа

5

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

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

У Эрланда Соммарскога есть отличная статья о том, как использовать обработку ошибок в SQL Server.

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

Поделиться

LittleBobbyTables — Au Revoir    

26 сентября 2010 в 16:14

2

Если бы я переводил moey с одного счета на другой, я бы хотел, чтобы он был 100% успешным или 100% неудачным:

UPDATE PersonalAccount SET Balance = Balance - 100 WHERE Username = 'gbn'
--what if the server caught fire here?
UPDATE SavingsAccount SET Balance = Balance + 100 WHERE Username = 'gbn'

Что касается того, что Вы читаете, полная чушь, за исключением того, что нет необходимости использовать BEGIN TRAN в триггере.

Пример из » вложенных хранимых процедур, содержащих шаблон отката TRY CATCH? «

Поделиться

gbn    

26 сентября 2010 в 16:18

Похожие вопросы:

Использование BEGIN TRANSACTION / ROLLBACK / COMMIT над различными курсорами / соединениями

Мне интересно, как ведут себя транзакции, когда различные команды (Begin/Start Transaction, Commit и т. д.) передаются через различные курсоры / соединения. I.e., какой из следующих наборов…

BeginTransaction не вызывает BEGIN TRANSACTION

У меня есть простой код, который использует BeginTransaction() . Результирующая транзакция назначается соединению, которое я использую для некоторых команд sql. Когда я профилирую полученный sql, я…

commit transaction и end transaction используются вместе

Я наткнулся на следующий T-SQL: … COMMIT TRANSACTION END TRANSACTION BEGIN TRANSACTION; … В чем разница между транзакциями COMMIT и END в данном случае?

как использовать begin transaction для нескольких запросов и разных таблиц (sqlite3, python)

Я использую следующий код для вставки данных в 2 таблицы: Вариации Var_entity #begin transaction cur.execute(begin) id_var = 0 for red in prop_redirect[results][bindings]: var_res =…

Ошибка TSQL: запрос commit transaction не имеет соответствующей инструкции begin сделки

Я изучаю TSQL и получаю ошибку при попытке обновить столбец в моей таблице продуктов. Он говорит мне, что запрос транзакции COMMIT не имеет соответствующей транзакции BEGIN, но у меня есть…

python sqlite «BEGIN TRANSACTION» и «COMMIT» команд

Если я хочу запустить транзакцию в своей базе данных через python, должен ли я выполнить команду sql ‘BEGIN TRANSACTION’ явно следующим образом: import sqlite3 conn = sqlite3.connect(db) c =…

Ошибка оператора PSQL «BEGIN TRANSACTION»

Я пытаюсь выполнить следующий запрос в PSQL — DO $$ BEGIN TRANSACTION LOCK TABLE tags IN EXCLUSIVE MODE; IF (SELECT COUNT(*) FROM tags WHERE user_id = 1) > 3 THEN INSERT INTO tags (user_id,…

Попробуйте поймать внутри TRANSACTION

Я написал процедуру, которая выбирает столбцы из таблицы и вставляет их в другую таблицу. Я поставил блок try/catch внутри транзакции. Если я получу какую-либо ошибку между ними, то мой код вставит…

Не использовать операторы «begin transaction» и «commit» в Postgresql

Всякий раз, когда я обращаюсь к базе данных PostgreSQL с terminal, я не использую операторы begin transaction или commit;. Тем не менее, изменения, внесенные мной в базу данных, являются…

Использование «BEGIN TRANSACTION» и «END TRANSACTION» для повышения производительности

Я прочитав пост, повышения производительности INSERT-per-second из SQLite? чтобы улучшить производительность моего SQLite. Один вопрос: если мне нужно выполнить следующие запросы: INSERT INTO INSERT…

Команда SQL SET TRANSACTION, COMMIT, ROLLBACK, SAVEPOINT в Oracle

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

Транзакции обрабатываются группой управляющих средств, с помощью которых пользователь может выдать команду INSERT, UPDATE или DELETE, указывающую начало серии команд изменения данных. После внесения изменений в базу данных пользователь может сохранить данные в базе, закончив транзакцию явным образом. Если же в любой момент транзакции возникает ошибка, пользователь может отменить изменения в базе данных, возвратив ее в состояние, в котором она находилась до начала транзакции.

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

SET TRANSACTION

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

• SET TRANSACTION – начинает транзакцию и устанавливает ее базовые характеристики.
• COMMIT – заканчивает текущую транзакцию сохранением изменений в базе данных и начинает новую транзакцию
• ROLLBACK – заканчивает текущую транзакцию отменой изменений в базе данных и начинает новую транзакцию
• SAVEPOINT – устанавливает контрольные точки (точки прерывания) для транзакции, разрешая неполный откат.

Команда SET TRANSACTION является необязательной, так как транзакция начинается:

• после регистрации пользователя в Oracle с помощью SQL*Plus и исполнения им первой команды
• после выдачи команды ROLLBACK или COMMIT, заканчивающей транзакцию
• после выхода пользователя из системы
• в результате аварии системы
• после выдачи команды описания данными, например ALTER DATABASE

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

Откат транзакции выполняется не только в результате выдачи команды ROLLBACK, но и неявно, когда выполнение оператора по той или иной причине заканчивается неудачно или когда пользователь отменяет оператор командой CTRL-C.

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

UPDATE my_table.products SET price=50 WHERE product=10010;

SAVEPOINT точка_сохранения;

UPDATE my_table.products SET price=200;

ROLLBACK TO SAVEPOINT точка_сохранения;

COMMIT;

Руководство по SQL. Транзакции. – PROSELYTE

Транзакция является рабочей единицей работы с базой данных (далее – БД). Это последовательность операций, выполняемых в логическом порядке пользователем, либо программой, которая работает с БД.

Мы можем сказать, что транзакция – это распространение изменений в БД. Например, если мы создаём, изменяем или удаляем запись, то мы выполняем транзакцию. Крайне важно контролировать транзакции для гарантирования.

Основные концепции транзакции описываются аббревиатурой ACID – Atomicity, Consistency, Isolation, Durability (Атомарность, Согласованность, Изолированность, Долговечность).

Атомарность

Атомарность гарантирует, что любая транзакция будет зафиксирована только целиком (полностью). Если одна из операций в последовательности не будет выполнена, то вся транзакция будет отменена. Тут вводится понятие “отката” (rollback). Т.е. внутри последовательности будут происходить определённые изменения, но по итогу все они будут отменены (“откачены”) и по итогу пользователь не увидит никаких изменений.

Согласованность

Это означает, что любая завершённая транзакция (транзакция, которая достигла завершения транзакции – end of transaction) фиксирует только допустимые результаты. Например, при переводе денег с одного счёта на другой, в случае, если деньги ушли с одного счёта, они должны прийти на другой (это и есть согласованность системы). Списание и зачисление  – это две разные транзакции, поэтому первая транзакция пройдёт без ошибок, а второй просто не будет. Именно поэтому крайне важно учитывать это свойство и поддерживать баланс системы.

Изолированность

Каждая транзакция должна быть изолирована от других, т.е. её результат не должен зависеть от выполнения других параллельных транзакций. На практике, изолированность крайне труднодостижимая вещь, поэтому здесь вводится понятие “уровни изолированности” (транзакция изолируется не полностью).

Долговечность

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

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

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

• COMMIT
  Сохраняет изменения
• ROLLBACK
  Откатывает (отменяет) изменения
• SAVEPOINT
  Создаёт точку к которой группа транзакций может откатиться
• SET TRANSACTION
  Размещает имя транзакции.

Команды управление транзакциями используются только для DML команд: INSERT, UPDATE, DELETE. Они не могут быть использованы во время создания, изменения или удаления таблицы.

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

mysql> SET autocommit=0;

Предположим, что у нас есть таблица developers, которая содержит следующие записи:

+----+-------------------+-----------+------------+--------+
| ID | NAME              | SPECIALTY | EXPERIENCE | SALARY |
+----+-------------------+-----------+------------+--------+
|  1 | Eugene Suleimanov | Java      |          2 |   2500 |
|  2 | Peter Romanenko   | Java      |          3 |   3500 |
|  3 | Andrei Komarov    | C++       |          3 |   2500 |
|  4 | Konstantin Geiko  | C#        |          2 |   2000 |
|  5 | Asya Suleimanova  | UI/UX     |          2 |   1800 |
|  7 | Ivan Ivanov       | C#        |          1 |    900 |
|  8 | Ludmila Geiko     | UI/UX     |          2 |   1800 |
+----+-------------------+-----------+------------+--------+

Удалим всех С++ разработчиков с помощью следующей команды:

mysql> DELETE FROM developers 
       WHERE SPECIALTY = 'C++';

mysql> COMMIT;

В результате выполнения данного запроса наша таблица будет содержать следующие записи:

+----+-------------------+-----------+------------+--------+
| ID | NAME              | SPECIALTY | EXPERIENCE | SALARY |
+----+-------------------+-----------+------------+--------+
|  1 | Eugene Suleimanov | Java      |          2 |   2500 |
|  2 | Peter Romanenko   | Java      |          3 |   3500 |
|  4 | Konstantin Geiko  | C#        |          2 |   2000 |
|  5 | Asya Suleimanova  | UI/UX     |          2 |   1800 |
|  7 | Ivan Ivanov       | C#        |          1 |    900 |
|  8 | Ludmila Geiko     | UI/UX     |          2 |   1800 |
+----+-------------------+-----------+------------+--------+

Теперь попробуем выполнить команду ROLLBACK:

mysql> ROLLBACK;

После выполнения данной команды наша таблица содержит следующие данные:

+----+-------------------+-----------+------------+--------+
| ID | NAME              | SPECIALTY | EXPERIENCE | SALARY |
+----+-------------------+-----------+------------+--------+
|  1 | Eugene Suleimanov | Java      |          2 |   2500 |
|  2 | Peter Romanenko   | Java      |          3 |   3500 |
|  3 | Andrei Komarov    | C++       |          3 |   2500 |
|  4 | Konstantin Geiko  | C#        |          2 |   2000 |
|  5 | Asya Suleimanova  | UI/UX     |          2 |   1800 |
|  6 | Ludmila Geiko     | UI/UX     |          2 |   1800 |
|  7 | Ivan Ivanov       | C#        |          1 |    900 |
+----+-------------------+-----------+------------+--------+

Как мы видим, запись С++ разработчика вновь в таблице.

Теперь постараемся разобраться с SAVEPOINT.
Для начала создадим точку сохранения, используя следующий запрос:

mysql> SAVEPOINT SP1;

Теперь выполним следующие запросы:

mysql> DELETE FROM developers WHERE ID = 7;
Query OK, 1 row affected (0.00 sec)

mysql> DELETE FROM developers WHERE ID = 6;
Query OK, 1 row affected (0.02 sec)

mysql> DELETE FROM developers WHERE ID = 5;
Query OK, 1 row affected (0.00 sec)

На данный момент наша таблица содержит следующие записи:

+----+-------------------+-----------+------------+--------+
| ID | NAME              | SPECIALTY | EXPERIENCE | SALARY |
+----+-------------------+-----------+------------+--------+
|  1 | Eugene Suleimanov | Java      |          2 |   2500 |
|  2 | Peter Romanenko   | Java      |          3 |   3500 |
|  3 | Andrei Komarov    | C++       |          3 |   2500 |
|  4 | Konstantin Geiko  | C#        |          2 |   2000 |
+----+-------------------+-----------+------------+--------+

Теперь мы вернёмся к точке сохранения SP1 с помощью команды:

mysql> ROLLBACK TO SP1;

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

+----+-------------------+-----------+------------+--------+
| ID | NAME              | SPECIALTY | EXPERIENCE | SALARY |
+----+-------------------+-----------+------------+--------+
|  1 | Eugene Suleimanov | Java      |          2 |   2500 |
|  2 | Peter Romanenko   | Java      |          3 |   3500 |
|  3 | Andrei Komarov    | C++       |          3 |   2500 |
|  4 | Konstantin Geiko  | C#        |          2 |   2000 |
|  5 | Asya Suleimanova  | UI/UX     |          2 |   1800 |
|  6 | Ludmila Geiko     | UI/UX     |          2 |   1800 |
|  7 | Ivan Ivanov       | C#        |          1 |    900 |
+----+-------------------+-----------+------------+--------+

Как мы видим, мы откатились к состоянию таблицы на момент создания точки сохранения SP1.

Теперь, когда нам больше не нужна данная точка сохранения, мы можем её освободить:

mysql> RELEASE SAVEPOINT SP1;

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

SET TRANSACTION READ ONLY;

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

SET TRANSACTION READ WRITE;

На этом мы заканчиваем изучение SQL транзакций.
В следующей статье мы рассмотрим функции даты.

404 | Микро Фокус

COMMIT — База знаний MariaDB

Оператор COMMIT завершает транзакцию, сохраняя любые изменения данных, чтобы они стали видимыми для последующих транзакций. Кроме того, разблокирует метаданные, измененные текущей транзакцией.Если autocommit установлен в 1, неявная фиксация выполняется после каждого оператора. В противном случае все транзакции, которые не заканчиваются явным COMMIT , неявно откатываются, и изменения теряются. Для этого можно явно использовать оператор ROLLBACK .

Требуемый синтаксис для оператора COMMIT следующий:

 COMMIT [РАБОТА] [И [NO] CHAIN] [[NO] RELEASE]
 

COMMIT — более важный терминатор транзакции, а также более интересный.Основная форма оператора COMMIT — это просто ключевое слово COMMIT (ключевое слово WORK — это просто шум, и его можно опустить без изменения эффекта).

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

RELEASE сообщает серверу отключить клиента сразу после текущей транзакции.

Есть варианты NO RELEASE и AND NO CHAIN ​​. По умолчанию коммиты не выполняют RELEASE или CHAIN ​​, но это поведение по умолчанию можно изменить с помощью системной переменной сервера completed_type. В этом случае параметры AND NO CHAIN ​​ и NO RELEASE отменяют значение сервера по умолчанию.

См. Также

[решено] Фиксация / откат транзакции — Форум по SQL Server

На самом деле это очень хороший вопрос.Я бы хотел, чтобы больше людей задавали подобные вопросы.

Немного более глубоких знаний, если кому интересно:

Все изменения в SQL Server происходят в контексте транзакции. Если вы запускаете запрос без указания каких-либо транзакций, транзакция подразумевается и фиксируется автоматически или автоматически откатывается в случае ошибки. Использование явных транзакций позволяет вам контролировать, как и если происходит фиксация, и дает вам возможность откатить транзакцию назад (эта часть уже была очень хорошо объяснена выше).

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

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

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

COMMIT TRANSACTION — Использование SQLite [Книга]

Имя

COMMIT TRANSACTION — Завершить и зафиксировать транзакцию

Описание

COMMIT
Команда TRANSACTION пытается закрыть и зафиксировать
любые изменения, сделанные во время текущей транзакции. Псевдоним
КОНЕЦ СДЕЛКИ май
также можно использовать. Если COMMIT
команда выполняется, когда SQLite находится в режиме автоматической фиксации, ошибка
будет издано.

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

Если фиксация не удалась,
транзакция может быть или не быть отменена, в зависимости от типа ошибки. Если
транзакция не откатывается, обычно можно просто перевыпустить
COMMIT команда. Если транзакция свернута
назад, все изменения, внесенные в рамках сделки,
потерял.Вы можете определить конкретное состояние базы данных
подключение с помощью вызова API sqlite3_get_autocommit () или путем попытки
для подачи команды BEGIN .
Если база данных возвращает логическую ошибку в результате
BEGIN команда, команда
база данных все еще находится в допустимой транзакции. Вы также можете оформить
ROLLBACK команда, которая
либо откатит транзакцию, если она все еще на месте,
или вернуть ошибку, если транзакция уже была откатана
назад.

Значительная стоимость
связанные с совершением транзакции. Подробнее см. BEGIN TRANSACTION …

Oracle / PLSQL: Заявление COMMIT

В этом руководстве Oracle объясняется, как использовать оператор Oracle COMMIT с синтаксисом и примерами.

Описание

В Oracle оператор COMMIT фиксирует все изменения для текущей транзакции. Как только фиксация будет выпущена, другие пользователи смогут увидеть ваши изменения.

Синтаксис

Синтаксис оператора COMMIT в Oracle / PLSQL:

 COMMIT [WORK] [предложение COMMENT] [предложение WRITE] [предложение FORCE]; 

Параметры или аргументы

РАБОТА

Необязательно. Он был добавлен Oracle для совместимости с SQL. Выполнение COMMIT с параметром WORK или без него приведет к тому же результату.

Статья

КОММЕНТАРИЙ

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

WRITE пункт

Необязательно. Он используется для указания приоритета, с которым информация повтора для зафиксированной транзакции должна быть записана в журнал повтора. В этом предложении вам нужно указать два параметра:

• WAIT или NOWAIT ( WAIT — значение по умолчанию, если не указано)
  • WAIT — означает, что фиксация возвращается клиенту только после того, как информация о повторном выполнении сохраняется в журнале повторного выполнения.
  • NOWAIT — означает, что фиксация возвращается клиенту сразу, независимо от состояния журнала повторов.
• НЕМЕДЛЕННЫЙ или ПАРТИЙНЫЙ ( НЕМЕДЛЕННЫЙ — значение по умолчанию, если не указано)
  • НЕМЕДЛЕННЫЙ — принудительно выполняет дисковый ввод-вывод, заставляя средство записи журнала записывать информацию повтора в журнал повтора.
  • BATCH — принудительно выполняет «групповую фиксацию» и буферизует журнал повторов для записи вместе с другими транзакциями.

FORCE статья

Необязательно. Он используется для принудительной фиксации транзакции, которая может быть повреждена или вызывает сомнения. С помощью этого предложения вы можете указать FORCE тремя способами:

• FORCE ‘строка’, [целое число] или FORCE CORRUPT_XID ‘строка’ или FORCE CORRUPT_XID_ALL
  • FORCE ‘строка’, [целое число] — позволяет зафиксировать поврежденную или сомнительную транзакцию в системе распределенной базы данных, указав идентификатор транзакции в одинарных кавычках как строка .Вы можете найти идентификатор транзакции в системном представлении под названием DBA_2PC_PENDING. Вы можете указать целое число , чтобы присвоить транзакции номер изменения системы, если вы не хотите фиксировать транзакцию с использованием текущего номера изменения системы.
  • FORCE CORRUPT_XID ‘строка’ — позволяет зафиксировать поврежденную или сомнительную транзакцию, указав идентификатор транзакции в одинарных кавычках как строка . Вы можете найти идентификатор транзакции в системном представлении под названием V $ CORRUPT_XID_LIST.
  • FORCE CORRUPT_XID_ALL — позволяет фиксировать все поврежденные транзакции.

Примечание

• У вас должны быть права администратора баз данных для доступа к системным представлениям — DBA_2PC_PENDING и V $ CORRUPT_XID_LIST.
• У вас должны быть права администратора базы данных, чтобы указать определенные функции оператора COMMIT.

Пример

Давайте рассмотрим пример, показывающий, как выполнить фиксацию в Oracle с помощью оператора COMMIT.

Например:

 COMMIT; 

Этот пример COMMIT будет работать так же, как следующий:

 COMMIT WORK WRITE WAIT WAIT НЕМЕДЛЕННО; 

В этом примере подразумевается ключевое слово WORK, а отсутствие предложения WRITE по умолчанию будет WRITE WAIT IMMEDIATE, поэтому первые 2 оператора COMMIT эквивалентны.

Комментарий

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

Например, вы можете написать COMMIT с комментарием двумя способами:

 COMMIT COMMMENT 'Это комментарий к транзакции'; 

ИЛИ

 COMMIT WORK COMMENT 'Это комментарий к транзакции'; 

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

Сила

Наконец, рассмотрим пример COMMIT, который показывает, как использовать предложение FORCE.

Например, вы можете записать COMMIT сомнительной транзакции двумя способами:

 COMMIT FORCE '22 .14.67 '; 

ИЛИ

 COMMIT WORK FORCE '22 .14.67 '; 

Поскольку ключевое слово WORK всегда подразумевается, оба этих примера COMMIT будут принудительно фиксировать поврежденную или сомнительную транзакцию, идентифицированную идентификатором транзакции ’22. 14,67 ‘.

SQL | СДЕЛКИ — GeeksforGeeks

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

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

Неполные шаги приводят к сбою транзакции.Транзакция базы данных по определению должна быть атомарной, согласованной, изолированной и надежной. Они широко известны как свойства КИСЛОТЫ
.

Как реализовать транзакции с помощью SQL?

Следующие команды используются для управления транзакциями. Важно отметить, что эти операторы не могут использоваться при создании таблиц и используются только с такими командами DML, как — INSERT, UPDATE и DELETE.

1. НАЧАТЬ ТРАНЗАКЦИЮ: Указывает начальную точку явной или локальной транзакции.

Синтаксис:

 НАЧАТЬ ТРАНЗАКЦИЮ имя_ транзакции; 

2. SET TRANSACTION: Добавляет имя в транзакцию.

Синтаксис:

 УСТАНОВИТЬ ОПЕРАЦИЮ [ЧИТАТЬ ЗАПИСАТЬ | ТОЛЬКО ЧИТАТЬ];
 

3. COMMIT: Если все в порядке со всеми операторами в рамках одной транзакции, все изменения записываются вместе в базе данных и называется подтверждено . Команда COMMIT сохраняет все транзакции в базе данных с момента последней команды COMMIT или ROLLBACK.

Синтаксис:

 COMMIT;
 

Пример: Пример таблицы 1

Ниже приведен пример, который удаляет те записи из таблицы, которые имеют возраст = 20, а затем ЗАКЛЮЧАЕТ изменения в базе данных.
Запросы:

 УДАЛИТЬ ОТ УЧАЩЕГОСЯ ГДЕ ВОЗРАСТ = 20;
СОВЕРШИТЬ;

 

Вывод:
Таким образом, две строки из таблицы будут удалены, и оператор SELECT будет иметь вид

4. ROLLBACK: Если какая-либо ошибка возникает с любым из сгруппированных операторов SQL, все изменения необходимо отменить. Процесс отмены изменений называется откатом . Эта команда может использоваться только для отмены транзакций с момента выполнения последней команды COMMIT или ROLLBACK.
Синтаксис:

 ROLLBACK;

 

Пример:
Из приведенного выше примера Пример таблицы1 ,
Удалите те записи из таблицы, у которых возраст = 20, а затем ОТКАТИТЕ изменения в базе данных.
Запросы:

 УДАЛИТЬ ОТ УЧАЩЕГОСЯ ГДЕ ВОЗРАСТ = 20;
ОТКАТ;
 

Выход:

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

Синтаксис команды точки сохранения:

 SAVEPOINT SAVEPOINT_NAME;
 

Эта команда используется только при создании SAVEPOINT среди всех транзакций.
Обычно ROLLBACK используется для отмены группы транзакций.
Синтаксис для отката к команде точки сохранения:

 ROLLBACK TO SAVEPOINT_NAME;

 

, вы можете выполнить ОТКАТ к любой точке сохранения в любое время, чтобы вернуть соответствующие данные в исходное состояние.
Пример:
Из приведенного выше примера Пример таблицы1 ,
Удалите те записи из таблицы, которые имеют возраст = 20, а затем ОТКАТИТЕ изменения в базе данных, сохранив точки сохранения.
Запросы:

 SAVEPOINT SP1;
// Точка сохранения создана.
УДАЛИТЬ ОТ студента, ГДЕ ВОЗРАСТ = 20;
// удалил
SAVEPOINT SP2;
// Точка сохранения создана.

 

Здесь SP1 — это первая SAVEPOINT, созданная перед удалением. В этом примере произошло одно удаление.
После удаления снова создается SAVEPOINT SP2.
Выход:

Произошло удаление, предположим, что вы передумали и решили ОТКАТИТЬСЯ к SAVEPOINT, который вы определили как SP1, который был до удаления. Удаление
отменяется этим заявлением,

 ОТКАТ К SP1;
// Откат завершен.

 

6. RELEASE SAVEPOINT: — Эта команда используется для удаления SAVEPOINT, которую вы создали.
Синтаксис:

 ОСВОБОДИТЬ SAVEPOINT SAVEPOINT_NAME

 

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

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

транзакций базы данных | Документация Django

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

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

atomic можно использовать как декоратор:

 из транзакции импорта django.db

@ transaction.atomic
def viewfunc (запрос):
    # Этот код выполняется внутри транзакции.
    do_stuff ()
 

и как менеджер контекста:

 из транзакции импорта django.db

def viewfunc (запрос):
    # Этот код выполняется в режиме автоматической фиксации (по умолчанию Django).
    do_stuff ()

    с transaction.atomic ():
        # Этот код выполняется внутри транзакции.
        do_more_stuff ()
 

Обертывание atomic в блоке try / except позволяет естественным образом обрабатывать
ошибок целостности:

 из django.db import IntegrityError, транзакция

@ transaction.atomic
def viewfunc (запрос):
    create_parent ()

    пытаться:
        с transaction.atomic ():
            generate_relationships ()
    кроме IntegrityError:
        handle_exception ()

    add_children ()
 

В этом примере, даже если generate_relationships () вызывает базу данных
ошибка, нарушив ограничение целостности, вы можете выполнять запросы в
add_children () , а изменения от create_parent () все еще
там и привязан к той же транзакции. Обратите внимание, что попытки любых операций
в generate_relationships () уже будет безопасно откат
когда вызывается handle_exception () , поэтому обработчик исключений также может
при необходимости работать с базой данных.

Избегайте перехвата исключений внутри atomic !

При выходе из блока atomic , Django проверяет, завершился ли он.
обычно или с исключением, чтобы определить, следует ли зафиксировать или свернуть
назад. Если вы перехватываете и обрабатываете исключения внутри блока atomic ,
вы можете скрыть от Django факт возникновения проблемы.Этот
может привести к неожиданному поведению.

Это в основном проблема DatabaseError и ее
подклассы, такие как IntegrityError . После такого
ошибка, транзакция прервана, и Django выполнит откат на
конец атомного блока . Если вы попытаетесь запустить базу данных
запросов до того, как произойдет откат, Django вызовет
TransactionManagementError . Ты можешь
также сталкиваются с этим поведением, когда обработчик сигнала, связанный с ORM, вызывает
исключение.

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

Если вы перехватываете исключения, вызванные необработанными SQL-запросами, поведение Django
не указано и зависит от базы данных.

Может потребоваться вручную вернуть состояние модели при откате транзакции.

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

Например, для MyModel с активным полем этот фрагмент
гарантирует, что if obj.active check в конце использует правильный
значение при обновлении активных до Истинно не удается в транзакции:

 из django. db import DatabaseError, transaction

obj = MyModel (active = False)
объектactive = True
пытаться:
    с transaction.atomic ():
        obj.save ()
кроме DatabaseError:
    obj.active = Ложь

если obj.active:
    ...
 

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

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

Под капотом, код управления транзакциями Django:

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

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

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

.