微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

Mysql学习MySQL的子查询及相关优化学习教程

分类：MySQL作者：编程之家AI导航网

《MysqL学习MysqL的子查询及相关优化学习教程》要点：
本文介绍了MysqL学习MysqL的子查询及相关优化学习教程，希望对您有用。如果有疑问，可以联系我们。

一、子查询
1、where型子查询
(把内层查询结果当作外层查询的比较条件)
MysqL学习

#不用order by 来查询最新的商品
select goods_id,goods_name from goods where goods_id = (select max(goods_id) from goods);

#取出每个栏目下最新的产品(goods_id唯一)
select cat_id,goods_id,goods_name from goods where goods_id in(select max(goods_id) from goods group by cat_id);

2、from型子查询
(把内层的查询结果供外层再次查询)
#用子查询查出挂科两门及以上的同学的平均成绩
思路：
MysqL学习

#先查出哪些同学挂科两门以上
select name,count(*) as gk from stu where score < 60 having gk >=2;
#以上查询结果,我们只要名字就可以了,所以再取一次名字
select name from (select name,count(*) as gk from stu having gk >=2) as t;
#找出这些同学了,那么再计算他们的平均分
select name,avg(score) from stu where name in (select name from (select name,count(*) as gk from stu having gk >=2) as t) group by name;

3、exists型子查询
(把外层查询结果拿到内层,看内层的查询是否成立)
MysqL学习

#查询哪些栏目下有商品,栏目表category,商品表goods
select cat_id,cat_name from category where exists(select * from goods where goods.cat_id = category.cat_id);

二、优化
从句式的形式看,子查询分为特殊格式子查询和非特殊格式子查询,特殊格式的子查询中又包括IN、ALL、ANY、SOME、EXISTS等类型的子查询,对于有的类型的子查询,MysqL有的支持优化,有的不支持,具体情况如下.MysqL学习

 MysqL学习

示例一,MysqL不支持对EXISTS类型的子查询的优化：MysqL学习

EXISTS类型的相关子查询,查询执行计划如下：MysqL学习

MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE EXISTS (SELECT 1 FROM t2 WHERE t1.a1= t2.a2 AND t2.a2>10);

+----+--------------------+-------+------+------+-------------+
| id | select_type    | table | type | key | Extra    |
+----+--------------------+-------+------+------+-------------+
| 1 | PRIMARY      | t1  | ALL | NULL | Using where |
| 2 | DEPENDENT SUBQUERY | t2  | ALL | NULL | Using where |
+----+--------------------+-------+------+------+-------------+
2 rows in set,2 warnings (0.00 sec)

被查询优化器处理后的语句为：MysqL学习

/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`a1` AS `a1`,`test`.`t1`.`b1` AS `b1`
from `test`.`t1`
where exists(/* select#2 */
  select 1
  from `test`.`t2`
  where ((`test`.`t1`.`a1` = `test`.`t2`.`a2`) and (`test`.`t2`.`a2` > 10))
)

从查询执行计划看,子查询存在,MysqL没有进一步做子查询的优化工作.MysqL学习

另外的一个EXISTS类型的相关子查询,查询执行计划如下：MysqL学习

MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE EXISTS (SELECT 1 FROM t2 WHERE t1.b1= t2.b2 AND t1.a1=10);

+----+--------------------+-------+------+------+-------------+
| id | select_type    | table | type | key | Extra    |
+----+--------------------+-------+------+------+-------------+
| 1 | PRIMARY      | t1  | ALL | NULL | Using where |
| 2 | DEPENDENT SUBQUERY | t2  | ALL | NULL | Using where |
+----+--------------------+-------+------+------+-------------+
2 rows in set,3 warnings (0.02 sec)

被查询优化器处理后的语句为：MysqL学习

/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`b1` AS `b1`
from `test`.`t1`
where exists(/* select#2 */
  select 1
  from `test`.`t2`
  where ((`test`.`t1`.`b1` = `test`.`t2`.`b2`) and (`test`.`t1`.`a1` = 10))
)

从查询执行计划看,MysqL没有进一步做子查询的优化工作.MysqL学习

 MysqL学习

示例二,MysqL不支持对NOT EXISTS类型的子查询的优化：MysqL学习

NOT EXISTS类型的相关子查询,查询执行计划如下：MysqL学习

MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t2 WHERE t1.a1= t2.a2 AND t2.a2>10);

+----+--------------------+-------+------+------+-------------+
| id | select_type    | table | type | key | Extra    |
+----+--------------------+-------+------+------+-------------+
| 1 | PRIMARY      | t1  | ALL | NULL | Using where |
| 2 | DEPENDENT SUBQUERY | t2  | ALL | NULL | Using where |
+----+--------------------+-------+------+------+-------------+
2 rows in set,`test`.`t1`.`b1` AS `b1`
from `test`.`t1`
where (not(exists(
  /* select#2 */ select 1
  from `test`.`t2`
  where ((`test`.`t1`.`a1` = `test`.`t2`.`a2`) and (`test`.`t2`.`a2` > 10))))
)

从查询执行计划看,MysqL没有进一步做子查询的优化工作.MysqL学习

 MysqL学习

另外的一个NOT EXISTS类型的相关子查询,查询执行计划如下：MysqL学习

MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE NOT EXISTS (SELECT 1 FROM t2 WHERE t1.b1= t2.b2 AND t1.a1=10);

+----+--------------------+-------+------+------+-------------+
| id | select_type    | table | type | key | Extra    |
+----+--------------------+-------+------+------+-------------+
| 1 | PRIMARY      | t1  | ALL | NULL | Using where |
| 2 | DEPENDENT SUBQUERY | t2  | ALL | NULL | Using where |
+----+--------------------+-------+------+------+-------------+
2 rows in set,3 warnings (0.00 sec)

被查询优化器处理后的语句为：MysqL学习

/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`b1` AS `b1`
from `test`.`t1`
where (not(exists(
  /* select#2 */ select 1
  from `test`.`t2`
  where ((`test`.`t1`.`b1` = `test`.`t2`.`b2`) and (`test`.`t1`.`a1` = 10))))
)

从查询执行计划看,MysqL没有进一步做子查询的优化工作.MysqL学习

 MysqL学习

示例三,MysqL支持对IN类型的子查询的优化,按也有不支持的情况存在：MysqL学习

IN非相关子查询,查询执行计划如下：MysqL学习

MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE t1.a1 IN (SELECT a2 FROM t2 WHERE t2.a2>10);

+----+--------------+-------------+------+------+----------------------------------------------------+
| id | select_type | table    | type | key | Extra  |
+----+--------------+-------------+------+------+----------------------------------------------------+
| 1 | SIMPLE    | <subquery2> | ALL | NULL | NULL  |
| 1 | SIMPLE    | t1     | ALL | NULL | Using where; Using join buffer (Block nested Loop) |
| 2 | MATERIALIZED | t2     | ALL | NULL | Using where  |
+----+--------------+-------------+------+------+----------------------------------------------------+
3 rows in set,1 warning (0.00 sec)

被查询优化器处理后的语句为：MysqL学习

/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`b1` AS `b1`
from `test`.`t1` semi join (`test`.`t2`)
where ((`test`.`t1`.`a1` = `<subquery2>`.`a2`) and (`test`.`t2`.`a2` > 10))

从查询执行计划看,表t2被物化后,与表t1执行了半连接(semi join).尽管有“subquery2”这样的内容看起来是子查询,但是表t2已经被上拉到表t1层执行了半连接,所以MysqL支持IN子查询优化为半连接操作.MysqL学习

 MysqL学习

另外一个IN非相关子查询,查询执行计划如下：MysqL学习

MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE t1.a1 IN (SELECT a2 FROM t2 WHERE t2.a2=10);

+----+--------------+-------------+------+------+----------------------------------------------------+
| id | select_type | table    | type | key | Extra  |
+----+--------------+-------------+------+------+----------------------------------------------------+
| 1 | SIMPLE    | <subquery2> | ALL | NULL | Using where  |
| 1 | SIMPLE    | t1     | ALL | NULL | Using where; Using join buffer (Block nested Loop) |
| 2 | MATERIALIZED | t2     | ALL | NULL | Using where  |
+----+--------------+-------------+------+------+----------------------------------------------------+
3 rows in set,1 warning (0.02 sec)

被查询优化器处理后的语句为：MysqL学习

/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`b1` AS `b1`
from `test`.`t1` semi join (`test`.`t2`)
where ((`<subquery2>`.`a2` = 10) and (`test`.`t1`.`a1` = 10) and (`test`.`t2`.`a2` = 10))

从查询执行计划看,子查询不存在,表t1和t2直接做了块嵌套循环半连接(Block nested Loop),把子查询上拉到父查询中用嵌套循环半连接完成IN操作.另外,由于子查询上拉,使得增加连接条件“a1=a2”,而原先的条件“a2=10”可以利用常量传递优化技术,使得“a1=a2=10”,所以查询执行计划中,两个索引扫描的条件分别为：a1 = 10、a2 = 10.MysqL学习

 MysqL学习

另外一个IN非相关子查询,查询执行计划如下：MysqL学习

MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE t1.a1 IN (SELECT a2 FROM t2 WHERE t1.a1=10);

+----+-------------+-------+------+------------------------------------------------------------------+
| id | select_type | table | type | Extra      |
+----+-------------+-------+------+------------------------------------------------------------------+
| 1 | SIMPLE   | t2  | ALL | Using where; Start temporary      |
| 1 | SIMPLE   | t1  | ALL | Using where; End temporary; Using join buffer (Block nested Loop)|
+----+-------------+-------+------+------------------------------------------------------------------+
2 rows in set,2 warnings (0.00 sec)

被查询优化器处理后的语句为：
/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`b1` AS `b1`
from `test`.`t1` semi join (`test`.`t2`)
where ((`test`.`t2`.`a2` = 10) and (`test`.`t1`.`a1` = 10))

从查询执行计划看,子子查询不存在,表t1和t2直接做了块嵌套循环连接(Block nested Loop),但属于半连接操作(semi join),把子查询上拉到父查询中用嵌套循环半连接完成IN操作.MysqL学习

 MysqL学习

示例四,MysqL支持对NOT IN类型的子查询的优化MysqL学习

NOT IN非相关子查询,查询执行计划如下：MysqL学习

MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE t1.a1 NOT IN (SELECT a2 FROM t2 WHERE t2.a2>10);

+----+-------------+-------+------+------+-------------+
| id | select_type | table | type | key | Extra    |
+----+-------------+-------+------+------+-------------+
| 1 | PRIMARY   | t1  | ALL | NULL | Using where |
| 2 | SUBQUERY  | t2  | ALL | NULL | Using where |
+----+-------------+-------+------+------+-------------+
2 rows in set,`test`.`t1`.`b1` AS `b1`
from `test`.`t1`
where (not(<in_optimizer>(
  `test`.`t1`.`a1`,`test`.`t1`.`a1` in (
    <materialize> (/* select#2 */
      select `test`.`t2`.`a2`
      from `test`.`t2`
      where (`test`.`t2`.`a2` > 10)
      having 1
    ),<primary_index_lookup>(
      `test`.`t1`.`a1` in <temporary table> on <auto_key>
      where ((`test`.`t1`.`a1` = `materialized-subquery`.`a2`))
    )
   )
  ))
)

从查询执行计划看,表t2做了子查询(SUBQUERY).而子查询被物化(materialize).所以,MysqL对于NOT IN子查询采用了物化的优化方式,但不支持子查询的消除.MysqL学习

 MysqL学习

另外一个NOT IN非相关子查询,查询执行计划如下：MysqL学习

MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE t1.a1 NOT IN (SELECT a2 FROM t2 WHERE t2.a2=10);

+----+-------------+-------+------+------+-------------+
| id | select_type | table | type | key | Extra    |
+----+-------------+-------+------+------+-------------+
| 1 | PRIMARY   | t1  | ALL | NULL | Using where |
| 2 | SUBQUERY  | t2  | ALL | NULL | Using where |
+----+-------------+-------+------+------+-------------+
2 rows in set,`test`.`t1`.`a1` in (
    <materialize> (/* select#2 */
      select `test`.`t2`.`a2`
      from `test`.`t2`
      where (`test`.`t2`.`a2` = 10)
      having 1
    ),<primary_index_lookup>(
      `test`.`t1`.`a1` in <temporary table> on <auto_key>
      where ((`test`.`t1`.`a1` = `materialized-subquery`.`a2`))
    )
  )
  ))
)

从查询执行计划看,但不支持子查询的消除.MysqL学习

 MysqL学习

示例五,MysqL支持对ALL类型的子查询的优化：MysqL学习

不相关的ALL子查询,查询执行计划如下：MysqL学习

MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE t1.a1 >ALL (SELECT a2 FROM t2 WHERE t2.a2>10);

+----+-------------+-------+------+------+-------------+
| id | select_type | table | type | key | Extra    |
+----+-------------+-------+------+------+-------------+
| 1 | PRIMARY   | t1  | ALL | NULL | Using where |
| 2 | SUBQUERY  | t2  | ALL | NULL | Using where |
+----+-------------+-------+------+------+-------------+
2 rows in set,`test`.`t1`.`b1` AS `b1`
from `test`.`t1`
where <not>((`test`.`t1`.`a1` <= <max>(
  /* select#2 */
  select `test`.`t2`.`a2`
  from `test`.`t2`
  where (`test`.`t2`.`a2` > 10)
  )
))

从查询执行计划看,出现了子查询(SUBQUERY),但是,子查询被“<= <max>”操作符限制,而子查询中的被查询列a2上存在唯一索引,所以可以利用索引求最值,所以MysqL支持“>ALL”式的子查询优化,子查询只被执行一次即可求得最大值.MysqL学习

 MysqL学习

不相关的ALL子查询,查询执行计划如下：MysqL学习

MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE t1.a1 =ALL (SELECT a2 FROM t2 WHERE t2.a2=10);

+----+--------------------+-------+------+------+-------------+
| id | select_type    | table | type | key | Extra    |
+----+--------------------+-------+------+------+-------------+
| 1 | PRIMARY      | t1  | ALL | NULL | Using where |
| 2 | DEPENDENT SUBQUERY | t2  | ALL | NULL | Using where |
+----+--------------------+-------+------+------+-------------+
2 rows in set,`test`.`t1`.`b1` AS `b1`
from `test`.`t1`
where <not>(<in_optimizer>(
  `test`.`t1`.`a1`,<exists>(
    /* select#2 */ select 1 from `test`.`t2`
    where ((`test`.`t2`.`a2` = 10) and
      <if>(outer_field_is_not_null,((<cache>(`test`.`t1`.`a1`) <> 10) or <cache>(isnull(10))),true
      )
    )
    having <if>(outer_field_is_not_null,<is_not_null_test>(`test`.`t2`.`a2`),true)
  )
))

从查询执行计划看,但是被查询优化器处理后的语句中包含“exists”,这表明MysqL对于“=ALL”式的子查询优化用“EXISTS strategy”方式优化,所以MysqL支持“=ALL”式的子查询优化.MysqL学习

 MysqL学习

不相关的ALL子查询,查询执行计划如下：MysqL学习

MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE t1.a1 <ALL (SELECT a2 FROM t2 WHERE t2.a2=10);

+----+-------------+-------+------+------+-------------+
| id | select_type | table | type | key | Extra    |
+----+-------------+-------+------+------+-------------+
| 1 | PRIMARY   | t1  | ALL | NULL | Using where |
| 2 | SUBQUERY  | t2  | ALL | NULL | Using where |
+----+-------------+-------+------+------+-------------+
2 rows in set,`test`.`t1`.`b1` AS `b1`
from `test`.`t1`
where <not>((`test`.`t1`.`a1` >= <min>
  (/* select#2 */
    select `test`.`t2`.`a2`
    from `test`.`t2`
    where (`test`.`t2`.`a2` = 10)
  )
))

从查询执行计划看,子查询被“>= <min>”操作符限制,所以MysqL支持“<ALL”式的子查询优化,子查询只被执行一次即可求得最小值.MysqL学习

 MysqL学习

示例六,MysqL支持对SOME类型的子查询的优化：MysqL学习

使用了“>SOME”式子的子查询被优化,查询执行计划如下：MysqL学习

MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE t1.a1 >SOME (SELECT a2 FROM t2 WHERE t2.a2>10);

+----+-------------+-------+------+------+-------------+
| id | select_type | table | type | key | Extra    |
+----+-------------+-------+------+------+-------------+
| 1 | PRIMARY   | t1  | ALL | NULL | Using where |
| 2 | SUBQUERY  | t2  | ALL | NULL | Using where |
+----+-------------+-------+------+------+-------------+
2 rows in set,1 warning (0.05 sec)

被查询优化器处理后的语句为：MysqL学习

 /* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`b1` AS `b1`
from `test`.`t1`
where <nop>((`test`.`t1`.`a1` > (
  /* select#2 */
  select min(`test`.`t2`.`a2`)
  from `test`.`t2`
  where (`test`.`t2`.`a2` > 10)
)))

从查询执行计划看,子查询被“min”函数限制,所以MysqL支持“>SOME”式的子查询优化,子查询只被执行一次即可求得最大值.MysqL学习

 MysqL学习

使用了“=SOME”式子的子查询被优化,查询执行计划如下：MysqL学习

MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE t1.a1 =SOME (SELECT a2 FROM t2 WHERE t2.a2=10);

+----+--------------+-------------+------+------+----------------------------------------------------+
| id | select_type | table    | type | key | Extra  |
+----+--------------+-------------+------+------+----------------------------------------------------+
| 1 | SIMPLE    | <subquery2> | ALL | NULL | Using where  |
| 1 | SIMPLE    | t1     | ALL | NULL | Using where; Using join buffer (Block nested Loop) |
| 2 | MATERIALIZED | t2     | ALL | NULL | Using where  |
+----+--------------+-------------+------+------+----------------------------------------------------+
3 rows in set,1 warning (0.01 sec)

被查询优化器处理后的语句为：MysqL学习

/* select#1 */ select `test`.`t1`.`id1` AS `id1`,没有出现了子查询,表t2被物化,与表t1进行了半连接.MysqL学习


 MysqL学习


使用了“<SOME”式子的子查询被优化,查询执行计划如下：MysqL学习




MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE t1.a1 <SOME (SELECT a2 FROM t2 WHERE t2.a2=10);







+----+-------------+-------+------+------+-------------+
| id | select_type | table | type | key | Extra    |
+----+-------------+-------+------+------+-------------+
| 1 | PRIMARY   | t1  | ALL | NULL | Using where |
| 2 | SUBQUERY  | t2  | ALL | NULL | Using where |
+----+-------------+-------+------+------+-------------+
2 rows in set,`test`.`t1`.`b1` AS `b1`
from `test`.`t1`
where <nop>(
  (
    `test`.`t1`.`a1` < (/* select#2 */
      select max(`test`.`t2`.`a2`)
      from `test`.`t2`
      where (`test`.`t2`.`a2` = 10)
    )
  )
)





从查询执行计划看,子查询被“max”函数限制,所以MysqL支持“<SOME”式的子查询优化,子查询只被执行一次即可求得最大值.MysqL学习


 MysqL学习


示例七,MysqL支持对ANY类型的子查询的优化：MysqL学习


使用了“>ANY”式子的子查询被优化,查询执行计划如下：MysqL学习




MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE t1.a1 >ANY (SELECT a2 FROM t2 WHERE t2.a2>10);







+----+-------------+-------+------+------+-------------+
| id | select_type | table | type | key | Extra    |
+----+-------------+-------+------+------+-------------+
| 1 | PRIMARY   | t1  | ALL | NULL | Using where |
| 2 | SUBQUERY  | t2  | ALL | NULL | Using where |
+----+-------------+-------+------+------+-------------+
2 rows in set,`test`.`t1`.`b1` AS `b1`
from `test`.`t1`
where <nop>(
  (
    `test`.`t1`.`a1` > (/* select#2 */
      select min(`test`.`t2`.`a2`)
      from `test`.`t2`
      where (`test`.`t2`.`a2` > 10)
    )
  )
)





从查询执行计划看,所以MysqL支持“>ANY”式的子查询优化,子查询只被执行一次即可求得最小值.MysqL学习


 MysqL学习


使用了“=ANY”式子的子查询被优化,查询执行计划如下：MysqL学习




MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE t1.a1 =ANY (SELECT a2 FROM t2 WHERE t2.a2>10);







+----+--------------+-------------+------+------+----------------------------------------------------+
| id | select_type | table    | type | key | Extra  |
+----+--------------+-------------+------+------+----------------------------------------------------+
| 1 | SIMPLE    | <subquery2> | ALL | NULL | NULL  |
| 1 | SIMPLE    | t1     | ALL | NULL | Using where; Using join buffer (Block nested Loop) |
| 2 | MATERIALIZED | t2     | ALL | NULL | Using where  |
+----+--------------+-------------+------+------+----------------------------------------------------+
3 rows in set,与表t1进行了半连接.MysqL学习


 MysqL学习


使用了“<ANY”式子的子查询被优化,查询执行计划如下：MysqL学习




MysqL> EXPLAIN EXTENDED SELECT * FROM t1 WHERE t1.a1 <ANY (SELECT a2 FROM t2 WHERE t2.a2>10);







+----+-------------+-------+------+------+-------------+
| id | select_type | table | type | key | Extra    |
+----+-------------+-------+------+------+-------------+
| 1 | PRIMARY   | t1  | ALL | NULL | Using where |
| 2 | SUBQUERY  | t2  | ALL | NULL | Using where |
+----+-------------+-------+------+------+-------------+
2 rows in set,`test`.`t1`.`b1` AS `b1`
from `test`.`t1`
where <nop>(
  (
    `test`.`t1`.`a1` < (/* select#2 */
      select max(`test`.`t2`.`a2`)
      from `test`.`t2`
      where (`test`.`t2`.`a2` > 10)
    )
  )
)





从查询执行计划看,所以MysqL支持“<ANY”式的子查询优化,子查询只被执行一次即可求得最大值.MysqL学习

                
                                 
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

一次彻底讲清如何处理mysql 的死锁问题
MySQL 死锁 是指两个或多个事务互相等待对方持有的锁，从而导致所有事务都无法继续执行的现象。在 InnoDB 存储引擎中，死锁是通过锁机制产生的，特别是在并发较高、业务逻辑复杂的情况下，更容易发生死锁。 一、MySQL 死锁的成因 MySQL 的死锁一般发生在 行级锁 上。常见的死锁成因包括：
MySQL 通过 Next-Key Locking 技术（行锁+间隙锁）避免幻读问题
在MySQL中，InnoDB引擎通过Next-Key Locking技术来解决幻读问题。幻读是一种事务并发问题，通常出现在Repeatable Read隔离级别下的范围查询操作中。幻读的现象是，事务在查询时多次执行相同的范围查询，但由于其他事务的插入或删除操作导致结果不一致，出现“幻觉”一样的记录。
一文彻底弄懂mysql的事务日志，undo log 和 redo log
在数据库事务管理中，Undo Log 和 Redo Log 是两种关键日志，用于保障事务的 原子性 和 持久性。它们的作用是确保数据库在出现崩溃、断电、宕机等故障时，能够进行恢复操作，从而保障数据一致性和完整性。它们通常用于支持事务的 ACID 特性中的 原子性 和 持久性。下面将分别介绍 Undo
select case when与IF的用法
case when概述 sql语句中的case语句与高级语言中的switch语句类似，是标准sql的语法，适用于一个条件判断有多种值的情况下分别执行不同的操作。 case when示例 IF语句示例 if else只能用在存储过程里
mysql 从一个表中查数据，插入另一个表
其实很简单，只是为了忘记，做个记录，用的时候方便。 不管是在网站开发还是在应用程序开发中，我们经常会碰到需要将MySQL或MS SQLServer某个表的数据批量导入到另一个表的情况，甚至有时还需要指定导入字段。 本文就将以MySQL数据库为例，介绍如何通过SQL命令行将某个表的所有数据或指定字段的
cmd命令行下登陆备份导入导出msql数据
1.进入服务，找到mysql服务，在属性里找到mysql的安装路径 2.登陆 mysql&#160;-h&#160;192.168.0.11 -P 3310 -u root -p 如果是访问的本机并且端口是默认的，那么-h和-P可以不写 3.备份 接着第一步&#160;mysqldump&#160;
sql中count(*)、count(col)、count(1)区别
count(*)和count(列)根本就是不等价的，count(*)是针对于全表的，而count(列)是针对于某一列的，如果此列值为空的话，count(列)是不会统计这一行的。 也就是说count(列)会用到索引，并且会过滤掉该列为null的那行。 而count(*)是全表扫描，并且只要某一条数据有
GROUP BY 和 ORDER BY一起使用时的注意点
order by的列，必须是出现在group by子句里的列ORDER BY要在GROUP BY的后面
sql中having、group by用法及常用聚合函数
having是用在聚合函数的用法。当我们在用聚合函数的时候，一般都要用到GROUP BY 先进行分组，然后再进行聚合函数的运算。运算完后就要用到HAVING 的用法了，就是进行判断了。 注意：select 后的字段，必须要么包含在group by中，要么包含在having 后的聚合函数里。 havi
MySQL 各类日志文件介绍
日志文件 1、错误日志 ErrorLog 错误日志记录了MyQLServer运行过程中所有较为严重的警告和错误信息，以及MySQLServer每次启动和关闭的详细信息。 在默认情况下，系统记录错误日志的功能是关闭的，错误信息被输出到标准错误输出（stderr），如果要开启系统记录错误日志的功能，需要
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native