一、子查詢
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”式的子查詢優化，子查詢只被執行一次即可求得最大值。
