一、子查询
1、where型子查询
（把内层查询结果当作外层查询的比较条件）
#不用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型子查询
(把内层的查询结果供外层再次查询)
#用子查询查出挂科两门及以上的同学的平均成绩
思路：
#先查出哪些同学挂科两门以上 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型子查询
（把外层查询结果拿到内层，看内层的查询是否成立）
#查询哪些栏目下有商品，栏目表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不支持对EXISTS类型的子查询的优化：
EXISTS类型的相关子查询，查询执行计划如下：
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)
被查询优化器处理后的语句为：
/* 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没有进一步做子查询的优化工作。
另外的一个EXISTS类型的相关子查询，查询执行计划如下：
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)
被查询优化器处理后的语句为：
/* 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`.`b1` = `test`.`t2`.`b2`) and (`test`.`t1`.`a1` = 10)) )
从查询执行计划看，子查询存在，MySQL没有进一步做子查询的优化工作。
示例二，MySQL不支持对NOT EXISTS类型的子查询的优化：
NOT EXISTS类型的相关子查询，查询执行计划如下：
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, 2 warnings (0.00 sec)
被查询优化器处理后的语句为：
/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`a1` AS `a1`, `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没有进一步做子查询的优化工作。
另外的一个NOT EXISTS类型的相关子查询，查询执行计划如下：
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)
被查询优化器处理后的语句为：
/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`a1` AS `a1`, `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支持对IN类型的子查询的优化，按也有不支持的情况存在：
IN非相关子查询，查询执行计划如下：
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)
被查询优化器处理后的语句为：
/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`a1` AS `a1`, `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子查询优化为半连接操作。
另外一个IN非相关子查询，查询执行计划如下：
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)
被查询优化器处理后的语句为：
/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`a1` AS `a1`, `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。
另外一个IN非相关子查询，查询执行计划如下：
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`.`a1` AS `a1`, `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支持对NOT IN类型的子查询的优化
NOT IN非相关子查询，查询执行计划如下：
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, 1 warning (0.02 sec)
被查询优化器处理后的语句为：
/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`a1` AS `a1`,
`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子查询采用了物化的优化方式，但不支持子查询的消除。
另外一个NOT IN非相关子查询，查询执行计划如下：
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, 1 warning (0.00 sec)
被查询优化器处理后的语句为：
/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`a1` AS `a1`,`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支持对ALL类型的子查询的优化：
不相关的ALL子查询，查询执行计划如下：
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, 1 warning (0.00 sec)
被查询优化器处理后的语句为：
/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`a1` AS `a1`,`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”式的子查询优化，子查询只被执行一次即可求得最大值。
不相关的ALL子查询，查询执行计划如下：
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, 1 warning (0.00 sec)
被查询优化器处理后的语句为：
/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`a1` AS `a1`,`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)
)
))
从查询执行计划看，出现了子查询（SUBQUERY），但是被查询优化器处理后的语句中包含“exists”，这表明MySQL对于“=ALL”式的子查询优化用“EXISTS strategy”方式优化，所以MySQL支持“=ALL”式的子查询优化。
不相关的ALL子查询，查询执行计划如下：
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, 1 warning (0.00 sec)
被查询优化器处理后的语句为：
/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`a1` AS `a1`,`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)
)
))
从查询执行计划看，出现了子查询（SUBQUERY），但是，子查询被“>= <min>”操作符限制，而子查询中的被查询列a2上存在唯一索引，所以可以利用索引求最值，所以MySQL支持“<ALL”式的子查询优化，子查询只被执行一次即可求得最小值。
示例六，MySQL支持对SOME类型的子查询的优化：
使用了“>SOME”式子的子查询被优化，查询执行计划如下：
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)
被查询优化器处理后的语句为：
/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`a1` AS `a1`, `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) )))
从查询执行计划看，出现了子查询（SUBQUERY），但是，子查询被“min”函数限制，而子查询中的被查询列a2上存在唯一索引，所以可以利用索引求最值，所以MySQL支持“>SOME”式的子查询优化，子查询只被执行一次即可求得最大值。
使用了“=SOME”式子的子查询被优化，查询执行计划如下：
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)
被查询优化器处理后的语句为：
/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`a1` AS `a1`, `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))
从查询执行计划看，没有出现了子查询，表t2被物化，与表t1进行了半连接。
使用了“<SOME”式子的子查询被优化，查询执行计划如下：
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.00 sec)
被查询优化器处理后的语句为：
/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`a1` AS `a1`,
`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)
)
)
)
从查询执行计划看，出现了子查询（SUBQUERY），但是，子查询被“max”函数限制，而子查询中的被查询列a2上存在唯一索引，所以可以利用索引求最值，所以MySQL支持“<SOME”式的子查询优化，子查询只被执行一次即可求得最大值。
示例七，MySQL支持对ANY类型的子查询的优化：
使用了“>ANY”式子的子查询被优化，查询执行计划如下：
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, 1 warning (0.00 sec)
被查询优化器处理后的语句为：
/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`a1` AS `a1`,
`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)
)
)
)
从查询执行计划看，出现了子查询（SUBQUERY），但是，子查询被“min”函数限制，而子查询中的被查询列a2上存在唯一索引，所以可以利用索引求最值，所以MySQL支持“>ANY”式的子查询优化，子查询只被执行一次即可求得最小值。
使用了“=ANY”式子的子查询被优化，查询执行计划如下：
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, 1 warning (0.02 sec)
被查询优化器处理后的语句为：
/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`a1` AS `a1`, `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进行了半连接。
使用了“<ANY”式子的子查询被优化，查询执行计划如下：
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, 1 warning (0.00 sec)
被查询优化器处理后的语句为：
/* select#1 */ select `test`.`t1`.`id1` AS `id1`,`test`.`t1`.`a1` AS `a1`,
`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)
)
)
)
从查询执行计划看，出现了子查询（SUBQUERY），但是，子查询被“max”函数限制，而子查询中的被查询列a2上存在唯一索引，所以可以利用索引求最值，所以MySQL支持“<ANY”式的子查询优化，子查询只被执行一次即可求得最大值。
免责声明：本站文章均来自网站采集或用户投稿，网站不提供任何软件下载或自行开发的软件！
如有用户或公司发现本站内容信息存在侵权行为，请邮件告知！ 858582#qq.com
白云城资源网 Copyright www.dyhadc.com
暂无“MySQL的子查询及相关优化学习教程”评论...
一口气升级7个大模型SaaS应用，百度智能云：突出一个“开箱即用” - 2024/11/5
这一波大模型产业落地浪潮里，不少企业其实处在 “干瞪眼“的状态。
一种情况是，很多大模型产品看得见却摸不着，在台上一个个遥遥领先——今天Sora技精四座，明天英伟达的机器人又赢得满堂彩，可是到了台下一问：啥时候能用上啊？答曰：遥遥无期。
另一种情况是，企业想用上大模型，却又难免瞻前顾后——既要考虑场景融合，又得兼顾安全性，还要考虑打通现有系统，再加上各种部署成本和繁琐的采购流程……最后只能拂袖：罢了，再等等吧。
这一波大模型产业落地浪潮里，不少企业其实处在 “干瞪眼“的状态。
一种情况是，很多大模型产品看得见却摸不着，在台上一个个遥遥领先——今天Sora技精四座，明天英伟达的机器人又赢得满堂彩，可是到了台下一问：啥时候能用上啊？答曰：遥遥无期。
另一种情况是，企业想用上大模型，却又难免瞻前顾后——既要考虑场景融合，又得兼顾安全性，还要考虑打通现有系统，再加上各种部署成本和繁琐的采购流程……最后只能拂袖：罢了，再等等吧。
稳了！魔兽国服回归的3条重磅消息！官宣时间再确认！
昨天有一位朋友在大神群里分享，自己亚服账号被封号之后居然弹出了国服的封号信息对话框。
这里面让他访问的是一个国服的战网网址，com.cn和后面的zh都非常明白地表明这就是国服战网。
而他在复制这个网址并且进行登录之后，确实是网易的网址，也就是我们熟悉的停服之后国服发布的暴雪游戏产品运营到期开放退款的说明。这是一件比较奇怪的事情，因为以前都没有出现这样的情况，现在突然提示跳转到国服战网的网址，是不是说明了简体中文客户端已经开始进行更新了呢？
更新日志
2024年11月05日
2024年11月05日
- 雨林唱片《赏》新曲+精选集SACD版[ISO][2.3G]
- 罗大佑与OK男女合唱团.1995-再会吧!素兰【音乐工厂】【WAV+CUE】
- 草蜢.1993-宝贝对不起（国）【宝丽金】【WAV+CUE】
- 杨培安.2009-抒·情（EP）【擎天娱乐】【WAV+CUE】
- 周慧敏《EndlessDream》[WAV+CUE]
- 彭芳《纯色角3》2007[WAV+CUE]
- 江志丰2008-今生为你[豪记][WAV+CUE]
- 罗大佑1994《恋曲2000》音乐工厂[WAV+CUE][1G]
- 群星《一首歌一个故事》赵英俊某些作品重唱企划[FLAC分轨][1G]
- 群星《网易云英文歌曲播放量TOP100》[MP3][1G]
- 方大同.2024-梦想家TheDreamer【赋音乐】【FLAC分轨】
- 李慧珍.2007-爱死了【华谊兄弟】【WAV+CUE】
- 王大文.2019-国际太空站【环球】【FLAC分轨】
- 群星《2022超好听的十倍音质网络歌曲(163)》U盘音乐[WAV分轨][1.1G]
- 童丽《啼笑姻缘》头版限量编号24K金碟[低速原抓WAV+CUE][1.1G]