mysql事务

最新推荐文章于 2022-10-24 15:09:21 发布
最新推荐文章于 2022-10-24 15:09:21 发布
阅读量528 收藏
点赞数
分类专栏： 笔记 文章标签： mysql 数据库 sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sugar_by/article/details/121353398
版权

==mysql事务
==什么是事务
mysql中，事务其实是一个最小的不可分割的工作单位。事务能够保证一个业务的完整性。比如：
银行转账：
用户 a->-100
update user set money=money-100 where name=‘a’;

用户 b->+100
update user set money=money+100 where name=‘b’;

实际的程序中，如果只有一条语句执行成功了，而另外一个没有执行成功？（a账号扣了100，但是b账号没有收到钱）
出现数据前后不一致。
多条 sql 语句，可能会有同时成功的要求，要么同时失败（这就是事务要解决的问题）

==mysql 中如何控制事务？

1.mysql 默认开启事务的（自动提交）。

mysql> select @@autocommit;
±-------------+
| @@autocommit |
±-------------+
| 1 |
±-------------+
1 row in set

==默认事务开启的作用是什么？
当我们去执行一个 sql 语句的时候，效果会立即体现出来，且不能回滚。

mysql> create database bank;
Query OK, 1 row affected

mysql> use bank;
Database changed

mysql> create table user(
id int primary key,
name varchar(20),
money int);
Query OK, 0 rows affected

mysql> insert into user values(1,‘a’,1000);
Query OK, 1 row affected

mysql> select *from user;
±—±-----±------+
| id | name | money |
±—±-----±------+
| 1 | a | 1000 |
±—±-----±------+
1 row in set
会立即显现出来

==事务回滚(rollback)：撤销 sql 语句执行效果

mysql> rollback;
Query OK, 0 rows affected

mysql> select *from user;
±—±-----±------+
| id | name | money |
±—±-----±------+
| 1 | a | 1000 |
±—±-----±------+
1 row in set

数据还在所有回滚失败，证明它是不可以回滚的
那怎么撤销 sql 语句呢
==我们可以把默认事务设置为0，也就是 设置 sql 自动提交为 false

mysql> set autocommit=0;
Query OK, 0 rows affected

mysql> select @@autocommit;
±-------------+
| @@autocommit |
±-------------+
| 0 |
±-------------+
1 row in set

==上面操作，关闭了 mysql 的自动提交（commit）；

mysql> insert into user values(2,‘b’,1000);
Query OK, 1 row affected

其实这里看到是一个临时的效果，它不是真实的，不是在我们的数据库里面，只是一张虚拟的表
（相当于把user表复制了一份（虚拟表），在虚拟表中呈现，真实的表是没有b这条数据的所以我们 rollback的时候是可以撤销的）
mysql> select *from user;
±—±-----±------+
| id | name | money |
±—±-----±------+
| 1 | a | 1000 |
| 2 | b | 1000 |
±—±-----±------+
2 rows in set

mysql> rollback;
Query OK, 0 rows affected

mysql> select *from user;
±—±-----±------+
| id | name | money |
±—±-----±------+
| 1 | a | 1000 |
±—±-----±------+
1 row in set

那如果说我们想让 b 这条数据提交怎么办呢

再一次插入数据
mysql> insert into user values(2,‘b’,1000);
Query OK, 1 row affected

手动提交
mysql> commit;
Query OK, 0 rows affected

再撤销，是不可以撤销的（体现了事务的特性—持久性）
mysql> rollback;
Query OK, 0 rows affected

mysql> select *from user;
±—±-----±------+
| id | name | money |
±—±-----±------+
| 1 | a | 1000 |
| 2 | b | 1000 |
±—±-----±------+
2 rows in set

要注意的：
==自动提交？@@autocommit =1
==手动提交？commit;
==事务回滚？rollback;

自动提交和手动提交是不可以撤销的那么问题来了
==如果说这个转账：
update user set money=money-100 where name=‘a’;
update user set money=money+100 where name=‘b’;

mysql> select *from user;
±—±-----±------+
| id | name | money |
±—±-----±------+
| 1 | a | 900 |
| 2 | b | 1100 |
±—±-----±------+
2 rows in set

mysql> rollback;
Query OK, 0 rows affected

mysql> select *from user;
±—±-----±------+
| id | name | money |
±—±-----±------+
| 1 | a | 1000 |
| 2 | b | 1000 |
±—±-----±------+
2 rows in set

==事务给了我们一个反悔的机会

==手动开启事务（begin_start_transaction）

mysql> set autocommit=1;
Query OK, 0 rows affected

mysql> select @@autocommit;
±-------------+
| @@autocommit |
±-------------+
| 1 |
±-------------+
1 row in set

不需要手动输入 commit 了，但是不可以撤销
但是如果我还是想撤销怎么办
可以通过输入 begin; 或者 start transaction; 都可以帮我们手动开启一个事务

mysql> select *from user;
±—±-----±------+
| id | name | money |
±—±-----±------+
| 1 | a | 1000 |
| 2 | b | 1000 |
±—±-----±------+
2 rows in set

mysql> update user set money=money-100 where name=‘a’;
Query OK, 1 row affected
Rows matched: 1 Changed: 1 Warnings: 0

mysql> update user set money=money+100 where name=‘b’;
Query OK, 1 row affected
Rows matched: 1 Changed: 1 Warnings: 0

mysql> select *from user;
±—±-----±------+
| id | name | money |
±—±-----±------+
| 1 | a | 900 |
| 2 | b | 1100 |
±—±-----±------+
2 rows in set

事务回滚
mysql> rollback;
Query OK, 0 rows affected

没有被撤销（因为我们把自动提交设置成了1，会帮我们提交）
mysql> select *from user;
±—±-----±------+
| id | name | money |
±—±-----±------+
| 1 | a | 900 |
| 2 | b | 1100 |
±—±-----±------+
2 rows in set

==手动开启事务（1）
begin;
update user set money=money-100 where name=‘a’;
update user set money=money+100 where name=‘b’;

手动开启一个事务
mysql> begin;
Query OK, 0 rows affected

进行转账
mysql> update user set money=money-100 where name=‘a’;
Query OK, 1 row affected
Rows matched: 1 Changed: 1 Warnings: 0

mysql> update user set money=money+100 where name=‘b’;
Query OK, 1 row affected
Rows matched: 1 Changed: 1 Warnings: 0

mysql> select *from user;
±—±-----±------+
| id | name | money |
±—±-----±------+
| 1 | a | 800 |
| 2 | b | 1200 |
±—±-----±------+
2 rows in set

事务回滚
mysql> rollback;
Query OK, 0 rows affected

被撤销
mysql> select *from user;
±—±-----±------+
| id | name | money |
±—±-----±------+
| 1 | a | 900 |
| 2 | b | 1100 |
±—±-----±------+
2 rows in set

==手动开启事务（2）
start transaction;
update user set money=money-100 where name=‘a’;
update user set money=money+100 where name=‘b’;

手动开启事务
mysql> start transaction;
Query OK, 0 rows affected

mysql> update user set money=money-100 where name=‘a’;
Query OK, 1 row affected
Rows matched: 1 Changed: 1 Warnings: 0

mysql> update user set money=money+100 where name=‘b’;
Query OK, 1 row affected
Rows matched: 1 Changed: 1 Warnings: 0

mysql> select *from user;
±—±-----±------+
| id | name | money |
±—±-----±------+
| 1 | a | 800 |
| 2 | b | 1200 |
±—±-----±------+
2 rows in set

事务回滚
mysql> rollback;
Query OK, 0 rows affected

被撤销
mysql> select *from user;
±—±-----±------+
| id | name | money |
±—±-----±------+
| 1 | a | 900 |
| 2 | b | 1100 |
±—±-----±------+
2 rows in set

如果我们想让它生效，手动输入commit (手动提交）
事务开启之后，一旦commit 提交，就不可以回滚（也就是当前这个事务在提交的时候就结束了）

手动开启事务
mysql> start transaction;
Query OK, 0 rows affected

mysql> update user set money=money-100 where name=‘a’;
Query OK, 1 row affected
Rows matched: 1 Changed: 1 Warnings: 0

mysql> update user set money=money+100 where name=‘b’;
Query OK, 1 row affected
Rows matched: 1 Changed: 1 Warnings: 0

手动提交
mysql> commit;
Query OK, 0 rows affected

mysql> select *from user;
±—±-----±------+
| id | name | money |
±—±-----±------+
| 1 | a | 800 |
| 2 | b | 1200 |
±—±-----±------+
2 rows in set

事务回滚
mysql> rollback;
Query OK, 0 rows affected

没有被撤销
mysql> select *from user;
±—±-----±------+
| id | name | money |
±—±-----±------+
| 1 | a | 800 |
| 2 | b | 1200 |
±—±-----±------+
2 rows in set

==事务的三大特征：
A 原子性：事务是最小的单位，不可以在分割。
B 一致性：事务要求，同一事务中的 sql 语句，必须保证同时成功或者同时失败。
I 隔离性：事务1 和 事务2 之间是具有隔离性的。
D 持久性: 事务一旦结束（进行（commit，rollback）其中一个），就不可以返回。

事务开启：
1.修改默认提交 set autocommit=0;
2.begin;
3.start transaction;

事务手动提交：
commit;

事务手动回滚：
rollback;

==事务隔离性：

  1. read uncommitted; 读未提交的
  2. read committed; 读已经提交的
  3. repeatable read; 可以重复读
  4. serializable; 串行化

==1. read uncommitted
如果有事务 a ，和事务 b,
a 事务对数据进行操作，在操作的过程中，事务没有被提交，但是 b 可以看见 a 操作的结果。
==这样会出现上面问题呢？
insert into user values(3,‘小明’,1000);
insert into user values(4,‘淘宝店’,1000);

mysql> select * from user;
±—±-------±------+
| id | name | money |
±—±-------±------+
| 1 | a | 800 |
| 2 | b | 1200 |
| 3 | 小明 | 1000 |
| 4 | 淘宝店 | 1000 |
±—±-------±------+
4 rows in set

小明去淘宝店买鞋子，鞋子要800块钱，给淘宝店转账，淘宝店查看钱是否到账

==如何查看数据库的隔离级别？

mysql 8.0 版本：
select @@global.transaction_isolation;（系统级别的）
select @@transaction_isolation;（会话级别的）

mysql 5.几 版本：
select @@global.tx_isolation;（系统级别的）
select @@tx_isolation;（会话级别的

系统级别的
REPEATABLE-READ是 mysql 默认隔离级别
mysql> select @@global.tx_isolation;
±----------------------+
| @@global.tx_isolation |
±----------------------+
| REPEATABLE-READ |
±----------------------+
1 row in set

会话级别的
mysql> select @@tx_isolation;
±----------------+
| @@tx_isolation |
±----------------+
| REPEATABLE-READ |
±----------------+
1 row in set

==如何修改隔离级别？

mysql> set global transaction isolation level read uncommitted;
Query OK, 0 rows affected

mysql> select @@global.tx_isolation;
±----------------------+
| @@global.tx_isolation |
±----------------------+
| READ-UNCOMMITTED |
±----------------------+
1 row in set

转账：小明在淘宝店买鞋子：800块钱
小明->成都 ATM
淘宝店->广州 ATM

开启事务（转账事务）
mysql> start transaction;
Query OK, 0 rows affected

mysql> update user set money=money-800 where name=‘小明’;
Query OK, 1 row affected
Rows matched: 1 Changed: 1 Warnings: 0

mysql> update user set money=money+800 where name=‘淘宝店’;
Query OK, 1 row affected
Rows matched: 1 Changed: 1 Warnings: 0

mysql> select * from user;
±—±-------±------+
| id | name | money |
±—±-------±------+
| 1 | a | 800 |
| 2 | b | 1200 |
| 3 | 小明 | 200 |
| 4 | 淘宝店 | 1800 |
±—±-------±------+
4 rows in set

==小明给淘宝店打电话，说你去查一下，是不是到账了

==淘宝店在广州查账
mysql> select * from user;
±—±-------±------+
| id | name | money |
±—±-------±------+
| 1 | a | 800 |
| 2 | b | 1200 |
| 3 | 小明 | 200 |
| 4 | 淘宝店 | 1800 |
±—±-------±------+
4 rows in set

==发货
==晚上请女朋友吃好吃的1800
==1800

==小明->成都
mysql> rollback;
Query OK, 0 rows affected

mysql> select * from user;
±—±-------±------+
| id | name | money |
±—±-------±------+
| 1 | a | 800 |
| 2 | b | 1200 |
| 3 | 小明 | 1000 |
| 4 | 淘宝店 | 1000 |
±—±-------±------+
4 rows in set

==结账的时候发现钱不够（他只能看到自己的，这里只是打个比方)淘宝店他不是程序员所以他不知道怎么回事

mysql> select * from user;
±—±-------±------+
| id | name | money |
±—±-------±------+
| 1 | a | 800 |
| 2 | b | 1200 |
| 3 | 小明 | 1000 |
| 4 | 淘宝店 | 1000 |
±—±-------±------+
4 rows in set

==如果俩个不同的地方，都在进行操作，如果事务a （小明开启的事务）开启之后，他的数据可以被其他事务（被淘宝店事务读取到回滚，所以钱变回了1000）读取到。
==这样就会出现（脏读）
==脏读：一个事务读到了另外一个事务没有提交的数据，就叫脏读
==实际开发是不允许脏读出现的。

==2. read committed;

查看隔离级别
mysql> select @@global.tx_isolation;
±----------------------+
| @@global.tx_isolation |
±----------------------+
| REPEATABLE-READ |
±----------------------+
1 row in set

修改隔离级别为 read committed
mysql> set global transaction isolation level read committed;
Query OK, 0 rows affected

查看隔离级别
mysql> select @@global.tx_isolation;
±----------------------+
| @@global.tx_isolation |
±----------------------+
| READ-COMMITTED |
±----------------------+
1 row in set

小张：银行会计（做报表的）

开启一个事务
start transaction;
mysql> select * from user;
±—±-------±------+
| id | name | money |
±—±-------±------+
| 1 | a | 800 |
| 2 | b | 1200 |
| 3 | 小明 | 1000 |
| 4 | 淘宝店 | 1000 |
±—±-------±------+
4 rows in set

小张出去上厕所

小王：
start transaction;

开了一个户
insert into user values(5,‘c’,100);
commit;

mysql> select * from user;
±—±-------±------+
| id | name | money |
±—±-------±------+
| 1 | a | 800 |
| 2 | b | 1200 |
| 3 | 小明 | 1000 |
| 4 | 淘宝店 | 1000 |
| 5 | c | 100 |
±—±-------±------+
5 rows in set

小张上厕所回来了
mysql> select avg(money) from user;
±-----------+
| avg(money) |
±-----------+
| 820.0000 |
±-----------+
1 row in set

发现money 的平均值不是1000，变少了

==虽然我只能读到另外一个事务提交的数据，但还是会出现问题，就是
读取同一个表的数据，发现前后不一致
这种现象称为不可重复读现象：在 read committed 出现

==3. repeatable read; 可以重复读

修改隔离级别
mysql> set global transaction isolation level repeatable read;
Query OK, 0 rows affected

mysql> select @@global.tx_isolation;
±----------------------+
| @@global.tx_isolation |
±----------------------+
| REPEATABLE-READ |
±----------------------+
1 row in set

==在 repeatable read 隔离级别下又会出现什么问题呢？

mysql> select * from user;
±—±-------±------+
| id | name | money |
±—±-------±------+
| 1 | a | 800 |
| 2 | b | 1200 |
| 3 | 小明 | 1000 |
| 4 | 淘宝店 | 1000 |
| 5 | c | 100 |
±—±-------±------+
5 rows in set

张三->成都
start transaction;

王五->北京
start transaction;

张三->成都
insert into user values(6,‘d’,1000);
commit;

mysql> select * from user;
±—±-------±------+
| id | name | money |
±—±-------±------+
| 1 | a | 800 |
| 2 | b | 1200 |
| 3 | 小明 | 1000 |
| 4 | 淘宝店 | 1000 |
| 5 | c | 100 |
| 6 | d | 1000 |
±—±-------±------+
6 rows in set

王五->北京

mysql> select * from user;
±—±-------±------+
| id | name | money |
±—±-------±------+
| 1 | a | 800 |
| 2 | b | 1200 |
| 3 | 小明 | 1000 |
| 4 | 淘宝店 | 1000 |
| 5 | c | 100 |
±—±-------±------+
5 rows in set

mysql> insert into user values(6,‘d’,1000);
1062 - Duplicate entry ‘6’ for key ‘PRIMARY’

==这种现象叫做幻读（王五这边查看的时候明明没有6号，但是却说已经存在）
事务 a 和事务 b 同时操作一张表，事务 a 提交的数据，也不能被事务 b 读到，就可能会造成幻读。

==4. serializable; 串行化

修改隔离级别为串行化
mysql> set global transaction isolation level serializable;
Query OK, 0 rows affected

mysql> select @@global.tx_isolation;
±----------------------+
| @@global.tx_isolation |
±----------------------+
| SERIALIZABLE |
±----------------------+
1 row in set

张三->成都

mysql> select * from user;
±—±-------±------+
| id | name | money |
±—±-------±------+
| 1 | a | 800 |
| 2 | b | 1200 |
| 3 | 小明 | 1000 |
| 4 | 淘宝店 | 1000 |
| 5 | c | 100 |
| 6 | d | 1000 |
±—±-------±------+
6 rows in set

start transaction;

王五->北京
start transaction;

张三->成都
insert into user values(7,‘赵铁柱’,1000);
commit;

mysql> select * from user;
±—±-------±------+
| id | name | money |
±—±-------±------+
| 1 | a | 800 |
| 2 | b | 1200 |
| 3 | 小明 | 1000 |
| 4 | 淘宝店 | 1000 |
| 5 | c | 100 |
| 6 | d | 1000 |
| 7 | 赵铁柱 | 1000 |
±—±-------±------+
7 rows in set

王五->北京
mysql> select * from user;
±—±-------±------+
| id | name | money |
±—±-------±------+
| 1 | a | 800 |
| 2 | b | 1200 |
| 3 | 小明 | 1000 |
| 4 | 淘宝店 | 1000 |
| 5 | c | 100 |
| 6 | d | 1000 |
| 7 | 赵铁柱 | 1000 |
±—±-------±------+
7 rows in set

张三->成都
start transaction;
insert into user values(8,‘王小花’,1000);
在这里插入图片描述

sql语句被卡住了
mysql> insert into user values(8,‘王小花’,1000);

那为什么会被卡住呢？
因为我这个隔离级别为串行化，
当 user 表被另外一个事务操作的时候，其他事务里面的写操作，是不可以进行。进入排队状态（串行化）（也就是当王五在查询的时候，张三是不能进行写入操作，如果进行写入操作的话就会进入等待状态（张三））
直到王五那边的事务提交之后，张三才可以执行了（在没有等待超时的情况下）

王五->北京
commit;

张三->成都
insert into user values(8,‘王小花’,1000);

mysql> insert into user values(8,‘王小花’,1000);
Query OK, 1 row affected

==串行化问题是，性能特差！！
性能：read uncommitted > read committed > repeatable read > serializable
隔离级别越高性能越差
隔离级别越低出现的问题就越多（read uncommitted什么问题都会出现， read committed出现不可重复问题，repeatable read出现幻读）
mysql默认级别是：repeatable read

是莱莱鸭
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MySQL事务
01-19
在MySQL中,所有的DML操作在执行之后都会有一个commit操作[隐式的] commit的意思就是用来提交事务. DTL,数据事务语言 事务的定义: 就是指一组相关的SQL操作,我们所有的操作都是处在事务中的 注意: 在数据库中**,执行...
研发人员必须了解的MySQL知识02
localhost65535的博客
02-27 1267
mysql事务
MySQL事务相关概念
SharingOfficer的博客
12-18 998
什么是事务 事务是一组数据库操作序列，是一个不可分割的单位。这些操作要么全做，要么不做。 事务的ACID特性 原子性(Atomicity) 事务必须作为一个完整的、不可分割的单位被执行。事务中所做的这些操作，要么全做，要么不做。 一致性(Consistency) 事务操作前后数据库应该由一个一致的状态转变为另一个一致的状态。一致状态的含义是数据库中的数据数据应满足完整性约束。 隔离性(Isolation) 多个事务并发执行时，一个事务的执行不能影响其他事务的执行。 持久性(Durabili
MySQL的事务
最新发布
bltyu2000的博客
10-24 1102
MySQL在我们后端开发的过程中应用广泛，我们要与数据库打交道。而事务是一个不可避免的问题，关于事务是什么？事务的操作，四大特性，并发事务问题以及事务的隔离级别。本文都会讲解。本文简单介绍了 MySQL 事务的语法和 ACID 特性，以及事务并发处理中可能出现的异常情况和为了防止这些异常而设计的事务隔离级别。
Java_MySQL数据库事务
weixin_42303077的博客
05-11 1192
1. 介绍 数据库事务是指逻辑上的一组操作，肯定是两个及两个以上饿操作，作用是保证这一组操作全部成功或失败。 加入A转账1000给B，这个其实就是一组操作： A的账户减去1000 B的账户加1000 有了事务控制之后，这个转账过程就有两个操作结果，而且将以上两个操作作为一组： 转账成功：A的账户要减去1000，B的账户加1000 转账失败：A，B的账户都不会发生变动 如果没有事务控制，那么可能会发生以下状况： A 的账户减去1000，但由于后续的执行中发生了异常，这样B的账户无法加1000，从而导致
MySql事务无法回滚的原因有哪些
09-10
使用MySQL时，如果发现事务无法回滚，但Hibernate、Spring、JDBC等配置又没有明显问题,到底是什么原因，下面与大家分享下
mySQL事务处理
06-13
关于mysql的事务处理 public static void StartTransaction(Connection con, String[] sqls) throws Exception { if (sqls == null) { return; } Statement sm = null; try { // 事务开始 System....
mysql 事务理解及相关操作
12-14
一、Mysql表引擎 Myisam: Mysql 5.5 版本之前的默认表引擎 ...在 MySQL 中只有使用了 Innodb 数据库引擎 的数据库或表才支持事务。 事务是一个不可再分的工作单元；通常将一组有序的增删改操作看做一个独立的执行单
Mysql事务处理详解
12-15
一、Mysql事务概念 　MySQL 事务主要用于处理操作量大，复杂度高的数据。由一步或几步数据库操作序列组成逻辑执行单元，这系列操作要么全部执行，要么全部放弃执行。在 MySQL 中只有使用了 Innodb 数据库引擎的...
MySQL----事务
emmmm.....
04-13 1265
MySQL----事务事务简介事务操作数据准备事务操作 事务简介 事务是一组操作的集合，它是一个不可分割的工作单位，事务会把所有的操作作为一个整体一起向系统提交或撤销操作请求，即这些操作要么同时成功，要么同时失败。 MySQL中事务默认是自动提交的，即当执行一条语句，MySQL会立即隐式的提交事务。 事务，防止在对数据进行操作时，中间抛出异常，部分数据改变，一部分数据无法发送对应的更改。 事务操作 数据准备 表格和数据： create table account ( id int auto_in
mysql事务是什么？
newoneobjectddd的博客
03-23 3038
事务的介绍，什么是事务？
mysql事务rename_MySQL 事务的学习整理
weixin_34377037的博客
02-08 411
事务是数据库区别文件系统的重要特征之一。在文件系统中，如果你正在写文件，但是操作系统突然崩溃了，这个时候文件有可能会被损坏的，当然也会有一些机制让文件恢复到某一个时间点，比如依靠原有的备份等。1引入事务的目的数据库系统引入事务的主要目的：事务会把数据库从一种一致状态转换成另外一种状态。在数据库提交工作时，可以确保其要么所有修改都已经保存了，要么所有修改都不保存。2 ACID简介InnoDB存储引擎...
一文搞懂什么是事务
srs1995的博客
12-18 812
一文搞懂什么是事务 [toc] 事务概念 我们要理解下事务概念： 什么是事务呢？事务是并发控制的单位，是用户定义的一个操作序列。有四个特性(ACID)： 原子性(Atomicity)： 事务是数据库的逻辑工作单位，事务中包括的诸操作要么全做，要么全不做。 一致性(Consistency)： 事务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。 隔离性(Isolation)： 一个事务的执行不能被其他事务干扰。 持续性/永久性(Durability)： 一个事
mysql中 什么是事务_“数据库中的事务”是什么？
weixin_32230811的博客
02-05 295
展开全部数据库事务(Database Transaction) ，事务是一系列作为一个32313133353236313431303231363533e59b9ee7ad9431333365646332逻辑单元来执行的操作集合。它是数据库维护数据一致性的单位，它将数据库从一致状态转变为新的一致状态，指作为单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行。 事务处理可以确保除非事务...
什么是mysql数据库事务_数据库事务（什么是事务）
weixin_42134097的博客
01-28 300
简介编辑数据库事务(简称：事务)是数据库管理系统执行过程中的一个逻辑单位，由一个有限的数据库操作序列构成。事务(Transaction)是并发控制的基本单位。所谓的事务，它是一个操作序列，这些操作要么都执行，要么都不执行，它是一个不可分割的工作单位。例如，银行转账工作：从一个账号扣款并使另一个账号增款，这两个操作要么都执行，要么都不执行,在关系数据库中,一个事务可以是一条SQL语句、一组SQL语句...
mysql事务的一个简单介绍
qq_45618388的博客
05-12 211
Mysql事务 基础概念 事务(transaction)是 访问和更新数据库的程序执行单元，事务中可能包含 一个或多个sql语句，这些语句要么都执行，要么都不执行。作为一个关系行数据库，Mysql支持事务 逻辑架构和存储引擎 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z2vakpFm-1589247064544)(/blog/img/sw1.png)] 图片来源：https://blog.csdn.net/fuzhongmin05/article/details/
【第四篇】MySQL事务详解【重点】
sunnyday0426的博客
03-03 1597
1.1 事务简介 MySQL数据库事务：事务是一组SQL语句组成的逻辑处理单元，这些操作要么全做要么全不做，是一个不可分割的工作单位。 MySQL中只有innodb引擎才能支持事务处理 数据库默认事务时自动提交的，也就是发一条SQL它就执行一条。如果想多条SQL放在一个事务中执行，则需要使用事务进行处理。当我们开启事务，并且没有提交，MySQL会自动回滚事务，或者我们使用rollback命令手动回滚事务。 事务（Transaction）：一个最小的不可再分的工作单元；通常一个事务对应一个完整的业务
mysql数据库永久设置手动提交事务(InnoDB存储引擎禁止autocommit默认开启)
热门推荐
灵魂自由的忙人
06-16 2万+
mysql数据库InnoDB存储引擎（默认情况下是自动控制提交事务）与其他关系型数据库在默认事务处理与其他关系型数据库略有不同，之前已经习惯Oracle数据库的手动提交事务的处理方式，mysql数据库只有innoDB存储引擎支持事务处理操作。      现在设置mysql数据库也是手动提交事务。方法有两种：①临时生效（只对当前客户端有效），②永久生效 ①临时生效（只对当前客户端有效） set

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值