我们前面两章详解了Explain的各个属性,我们看到的都是mysql已经生成的执行计划,那这个执行计划的是如何生成的?我们能看到一些过程指标数据吗?实际mysql贴心为我们提供了执行计划的各项成本评估指标的以及优化器生成执行计划的整个过程的方法。

一、查看执行计划计算的成本数据

我们上边介绍的EXPLAIN语句输出中缺少了一个衡量执行计划好坏的重要属性 -成本。那如何查看具体的成本呢?MySQL也贴心的为我们提供了一种查看某个执行计划花费的成本的方式-Json格式的执行计划。我们只需要在EXPLAIN单词和真正的查询语句中间加上FORMAT=JSON。

    1. mysql> EXPLAIN FORMAT=JSON SELECT * FROM s1 INNER JOIN s2 ON s1.key1 = s2.key2 WHERE s1.common_field = 'a'\G
      1. *************************** 1. row ***************************
          1. EXPLAIN: {
            1. "query_block": {
              1. "select_id": 1, # 整个查询语句只有1个SELECT关键字,该关键字对应的id号为1
                1. "cost_info": {
                  1. "query_cost": "3197.16" # 整个查询的执行成本预计为3197.16
                    1. },
                      1. "nested_loop": [ # 几个表之间采用嵌套循环连接算法执行
                          1. # 以下是参与嵌套循环连接算法的各个表的信息
                            1. {
                              1. "table": {
                                1. "table_name": "s1", # s1表是驱动表
                                  1. "access_type": "ALL", # 访问方法为ALL,意味着使用全表扫描访问
                                    1. "possible_keys": [ # 可能使用的索引
                                      1. "idx_key1"
                                        1. ],
                                          1. "rows_examined_per_scan": 9688, # 查询一次s1表大致需要扫描9688条记录
                                            1. "rows_produced_per_join": 968, # 驱动表s1的扇出是968
                                              1. "filtered": "10.00", # condition filtering代表的百分比
                                                1. "cost_info": {
                                                  1. "read_cost": "1840.84", # 稍后解释
                                                    1. "eval_cost": "193.76", # 稍后解释
                                                      1. "prefix_cost": "2034.60", # 单次查询s1表总共的成本
                                                        1. "data_read_per_join": "1M" # 读取的数据量
                                                          1. },
                                                            1. "used_columns": [ # 执行查询中涉及到的列
                                                              1. "id",
                                                                1. "key1",
                                                                  1. "key2",
                                                                    1. "key3",
                                                                      1. "key_part1",
                                                                        1. "key_part2",
                                                                          1. "key_part3",
                                                                            1. "common_field"
                                                                              1. ],
                                                                                  1. # 对s1表访问时针对单表查询的条件
                                                                                    1. "attached_condition": "((`xiaohaizi`.`s1`.`common_field` = 'a') and (`xiaohaizi`.`s1`.`key1` is not null))"
                                                                                      1. }
                                                                                        1. },
                                                                                          1. {
                                                                                            1. "table": {
                                                                                              1. "table_name": "s2", # s2表是被驱动表
                                                                                                1. "access_type": "ref", # 访问方法为ref,意味着使用索引等值匹配的方式访问
                                                                                                  1. "possible_keys": [ # 可能使用的索引
                                                                                                    1. "idx_key2"
                                                                                                      1. ],
                                                                                                        1. "key": "idx_key2", # 实际使用的索引
                                                                                                          1. "used_key_parts": [ # 使用到的索引列
                                                                                                            1. "key2"
                                                                                                              1. ],
                                                                                                                1. "key_length": "5", # key_len
                                                                                                                  1. "ref": [ # 与key2列进行等值匹配的对象
                                                                                                                    1. "xiaohaizi.s1.key1"
                                                                                                                      1. ],
                                                                                                                        1. "rows_examined_per_scan": 1, # 查询一次s2表大致需要扫描1条记录
                                                                                                                          1. "rows_produced_per_join": 968, # 被驱动表s2的扇出是968(由于后边没有多余的表进行连接,所以这个值也没啥用)
                                                                                                                            1. "filtered": "100.00", # condition filtering代表的百分比
                                                                                                                                1. # s2表使用索引进行查询的搜索条件
                                                                                                                                  1. "index_condition": "(`xiaohaizi`.`s1`.`key1` = `xiaohaizi`.`s2`.`key2`)",
                                                                                                                                    1. "cost_info": {
                                                                                                                                      1. "read_cost": "968.80", # 稍后解释
                                                                                                                                        1. "eval_cost": "193.76", # 稍后解释
                                                                                                                                          1. "prefix_cost": "3197.16", # 单次查询s1、多次查询s2表总共的成本
                                                                                                                                            1. "data_read_per_join": "1M" # 读取的数据量
                                                                                                                                              1. },
                                                                                                                                                1. "used_columns": [ # 执行查询中涉及到的列
                                                                                                                                                  1. "id",
                                                                                                                                                    1. "key1",
                                                                                                                                                      1. "key2",
                                                                                                                                                        1. "key3",
                                                                                                                                                          1. "key_part1",
                                                                                                                                                            1. "key_part2",
                                                                                                                                                              1. "key_part3",
                                                                                                                                                                1. "common_field"
                                                                                                                                                                  1. ]
                                                                                                                                                                    1. }
                                                                                                                                                                      1. }
                                                                                                                                                                        1. ]
                                                                                                                                                                          1. }
                                                                                                                                                                            1. }
                                                                                                                                                                              1. 1 row in set, 2 warnings (0.00 sec)
                                                                                                                                                                            1.  

                                                                                                                                                                            二、查询语句重写后的语句

                                                                                                                                                                            在我们使用EXPLAIN语句查看了某个查询的执行计划后,紧接着还可以使用SHOW WARNINGS语句查看与这个查询的执行计划有关的一些扩展信息,其中Message字段展示的信息类似于查询优化器将我们的查询语句重写后的语句。

                                                                                                                                                                              1. mysql> EXPLAIN SELECT s1.key1, s2.key1 FROM s1 LEFT JOIN s2 ON s1.key1 = s2.key1 WHERE s2.common_field IS NOT NULL;
                                                                                                                                                                                1. +----+-------------+-------+------------+------+---------------+----------+---------+-------------------+------+----------+-------------+
                                                                                                                                                                                  1. | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
                                                                                                                                                                                    1. +----+-------------+-------+------------+------+---------------+----------+---------+-------------------+------+----------+-------------+
                                                                                                                                                                                      1. | 1 | SIMPLE | s2 | NULL | ALL | idx_key1 | NULL | NULL | NULL | 9954 | 90.00 | Using where |
                                                                                                                                                                                        1. | 1 | SIMPLE | s1 | NULL | ref | idx_key1 | idx_key1 | 303 | xiaohaizi.s2.key1 | 1 | 100.00 | Using index |
                                                                                                                                                                                          1. +----+-------------+-------+------------+------+---------------+----------+---------+-------------------+------+----------+-------------+
                                                                                                                                                                                            1. 2 rows in set, 1 warning (0.00 sec)
                                                                                                                                                                                                1. mysql> SHOW WARNINGS\G
                                                                                                                                                                                                  1. *************************** 1. row ***************************
                                                                                                                                                                                                    1. Level: Note
                                                                                                                                                                                                      1. Code: 1003
                                                                                                                                                                                                        1. Message: /* select#1 */ select `xiaohaizi`.`s1`.`key1` AS `key1`,`xiaohaizi`.`s2`.`key1` AS `key1` from `xiaohaizi`.`s1` join `xiaohaizi`.`s2` where ((`xiaohaizi`.`s1`.`key1` = `xiaohaizi`.`s2`.`key1`) and (`xiaohaizi`.`s2`.`common_field` is not null))
                                                                                                                                                                                                          1. 1 row in set (0.00 sec)
                                                                                                                                                                                                        1.  

                                                                                                                                                                                                        比如我们上边的查询本来是一个左(外)连接查询,但是有一个s2.common_field IS NOT NULL的条件,着就会导致查询优化器把左(外)连接查询优化为内连接查询,从SHOW WARNINGSMessage字段也可以看出来,原本的LEFT JOIN已经变成了JOIN

                                                                                                                                                                                                        但是大家一定要注意,我们说Message字段展示的信息类似于查询优化器将我们的查询语句重写后的语句,并不是等价于,也就是说Message字段展示的信息并不是标准的查询语句,在很多情况下并不能直接拿来运行。

                                                                                                                                                                                                        三、查看优化器生成执行计划的过程

                                                                                                                                                                                                        对于MySQL 5.6以及之前的版本来说,查询优化器就像是一个黑盒子一样,你只能通过EXPLAIN语句查看到最后优化器决定使用的执行计划,却无法知道它为什么做这个决策。在MySQL 5.6以及之后的版本中,MySQL提出了一个optimizer trace的功能,这个功能可以让我们方便的查看优化器生成执行计划的整个过程。

                                                                                                                                                                                                        功能的开启与关闭由系统变量optimizer_trace决定(默认是关闭的)。当我们打开这个功能,我们就可以输入我们想要查看优化过程的查询语句,当该查询语句执行完成后,就可以到information_schema数据库下的OPTIMIZER_TRACE表中查看完整的优化过程。具体的流程:

                                                                                                                                                                                                          1. # 1. 打开optimizer trace功能 (默认情况下它是关闭的):
                                                                                                                                                                                                            1. SET optimizer_trace="enabled=on";
                                                                                                                                                                                                                1. # 2. 这里输入你自己的查询语句
                                                                                                                                                                                                                  1. SELECT ...;
                                                                                                                                                                                                                      1. # 3. 从OPTIMIZER_TRACE表中查看上一个查询的优化过程
                                                                                                                                                                                                                        1. SELECT * FROM information_schema.OPTIMIZER_TRACE;
                                                                                                                                                                                                                            1. # 4. 可能你还要观察其他语句执行的优化过程,重复上边的第2、3步
                                                                                                                                                                                                                              1. ...
                                                                                                                                                                                                                                  1. # 5. 当你停止查看语句的优化过程时,把optimizer trace功能关闭
                                                                                                                                                                                                                                    1. SET optimizer_trace="enabled=off";
                                                                                                                                                                                                                                  1.  

                                                                                                                                                                                                                                  举例说明一下:

                                                                                                                                                                                                                                    1. SET optimizer_trace="enabled=on";
                                                                                                                                                                                                                                        1. SELECT * FROM s1 WHERE
                                                                                                                                                                                                                                          1. key1 > 'z' AND
                                                                                                                                                                                                                                            1. key2 < 1000000 AND
                                                                                                                                                                                                                                              1. key3 IN ('a', 'b', 'c') AND
                                                                                                                                                                                                                                                1. common_field = 'abc';
                                                                                                                                                                                                                                                    1. SELECT * FROM information_schema.OPTIMIZER_TRACE\G
                                                                                                                                                                                                                                                  1.  

                                                                                                                                                                                                                                                  输出:

                                                                                                                                                                                                                                                    1. *************************** 1. row ***************************
                                                                                                                                                                                                                                                      1. # 分析的查询语句是什么
                                                                                                                                                                                                                                                        1. QUERY: SELECT * FROM s1 WHERE
                                                                                                                                                                                                                                                          1. key1 > 'z' AND
                                                                                                                                                                                                                                                            1. key2 < 1000000 AND
                                                                                                                                                                                                                                                              1. key3 IN ('a', 'b', 'c') AND
                                                                                                                                                                                                                                                                1. common_field = 'abc'
                                                                                                                                                                                                                                                                    1. # 优化的具体过程
                                                                                                                                                                                                                                                                      1. TRACE: {
                                                                                                                                                                                                                                                                        1. "steps": [
                                                                                                                                                                                                                                                                          1. {
                                                                                                                                                                                                                                                                            1. "join_preparation": { # prepare阶段
                                                                                                                                                                                                                                                                              1. "select#": 1,
                                                                                                                                                                                                                                                                                1. "steps": [
                                                                                                                                                                                                                                                                                  1. {
                                                                                                                                                                                                                                                                                    1. "IN_uses_bisection": true
                                                                                                                                                                                                                                                                                      1. },
                                                                                                                                                                                                                                                                                        1. {
                                                                                                                                                                                                                                                                                          1. "expanded_query": "/* select#1 */ select `s1`.`id` AS `id`,`s1`.`key1` AS `key1`,`s1`.`key2` AS `key2`,`s1`.`key3` AS `key3`,`s1`.`key_part1` AS `key_part1`,`s1`.`key_part2` AS `key_part2`,`s1`.`key_part3` AS `key_part3`,`s1`.`common_field` AS `common_field` from `s1` where ((`s1`.`key1` > 'z') and (`s1`.`key2` < 1000000) and (`s1`.`key3` in ('a','b','c')) and (`s1`.`common_field` = 'abc'))"
                                                                                                                                                                                                                                                                                            1. }
                                                                                                                                                                                                                                                                                              1. ] /* steps */
                                                                                                                                                                                                                                                                                                1. } /* join_preparation */
                                                                                                                                                                                                                                                                                                  1. },
                                                                                                                                                                                                                                                                                                    1. {
                                                                                                                                                                                                                                                                                                      1. "join_optimization": { # optimize阶段
                                                                                                                                                                                                                                                                                                        1. "select#": 1,
                                                                                                                                                                                                                                                                                                          1. "steps": [
                                                                                                                                                                                                                                                                                                            1. {
                                                                                                                                                                                                                                                                                                              1. "condition_processing": { # 处理搜索条件
                                                                                                                                                                                                                                                                                                                1. "condition": "WHERE",
                                                                                                                                                                                                                                                                                                                  1. # 原始搜索条件
                                                                                                                                                                                                                                                                                                                    1. "original_condition": "((`s1`.`key1` > 'z') and (`s1`.`key2` < 1000000) and (`s1`.`key3` in ('a','b','c')) and (`s1`.`common_field` = 'abc'))",
                                                                                                                                                                                                                                                                                                                      1. "steps": [
                                                                                                                                                                                                                                                                                                                        1. {
                                                                                                                                                                                                                                                                                                                          1. # 等值传递转换
                                                                                                                                                                                                                                                                                                                            1. "transformation": "equality_propagation",
                                                                                                                                                                                                                                                                                                                              1. "resulting_condition": "((`s1`.`key1` > 'z') and (`s1`.`key2` < 1000000) and (`s1`.`key3` in ('a','b','c')) and (`s1`.`common_field` = 'abc'))"
                                                                                                                                                                                                                                                                                                                                1. },
                                                                                                                                                                                                                                                                                                                                  1. {
                                                                                                                                                                                                                                                                                                                                    1. # 常量传递转换
                                                                                                                                                                                                                                                                                                                                      1. "transformation": "constant_propagation",
                                                                                                                                                                                                                                                                                                                                        1. "resulting_condition": "((`s1`.`key1` > 'z') and (`s1`.`key2` < 1000000) and (`s1`.`key3` in ('a','b','c')) and (`s1`.`common_field` = 'abc'))"
                                                                                                                                                                                                                                                                                                                                          1. },
                                                                                                                                                                                                                                                                                                                                            1. {
                                                                                                                                                                                                                                                                                                                                              1. # 去除没用的条件
                                                                                                                                                                                                                                                                                                                                                1. "transformation": "trivial_condition_removal",
                                                                                                                                                                                                                                                                                                                                                  1. "resulting_condition": "((`s1`.`key1` > 'z') and (`s1`.`key2` < 1000000) and (`s1`.`key3` in ('a','b','c')) and (`s1`.`common_field` = 'abc'))"
                                                                                                                                                                                                                                                                                                                                                    1. }
                                                                                                                                                                                                                                                                                                                                                      1. ] /* steps */
                                                                                                                                                                                                                                                                                                                                                        1. } /* condition_processing */
                                                                                                                                                                                                                                                                                                                                                          1. },
                                                                                                                                                                                                                                                                                                                                                            1. {
                                                                                                                                                                                                                                                                                                                                                              1. # 替换虚拟生成列
                                                                                                                                                                                                                                                                                                                                                                1. "substitute_generated_columns": {
                                                                                                                                                                                                                                                                                                                                                                  1. } /* substitute_generated_columns */
                                                                                                                                                                                                                                                                                                                                                                    1. },
                                                                                                                                                                                                                                                                                                                                                                      1. {
                                                                                                                                                                                                                                                                                                                                                                        1. # 表的依赖信息
                                                                                                                                                                                                                                                                                                                                                                          1. "table_dependencies": [
                                                                                                                                                                                                                                                                                                                                                                            1. {
                                                                                                                                                                                                                                                                                                                                                                              1. "table": "`s1`",
                                                                                                                                                                                                                                                                                                                                                                                1. "row_may_be_null": false,
                                                                                                                                                                                                                                                                                                                                                                                  1. "map_bit": 0,
                                                                                                                                                                                                                                                                                                                                                                                    1. "depends_on_map_bits": [
                                                                                                                                                                                                                                                                                                                                                                                      1. ] /* depends_on_map_bits */
                                                                                                                                                                                                                                                                                                                                                                                        1. }
                                                                                                                                                                                                                                                                                                                                                                                          1. ] /* table_dependencies */
                                                                                                                                                                                                                                                                                                                                                                                            1. },
                                                                                                                                                                                                                                                                                                                                                                                              1. {
                                                                                                                                                                                                                                                                                                                                                                                                1. "ref_optimizer_key_uses": [
                                                                                                                                                                                                                                                                                                                                                                                                  1. ] /* ref_optimizer_key_uses */
                                                                                                                                                                                                                                                                                                                                                                                                    1. },
                                                                                                                                                                                                                                                                                                                                                                                                      1. {
                                                                                                                                                                                                                                                                                                                                                                                                          1. # 预估不同单表访问方法的访问成本
                                                                                                                                                                                                                                                                                                                                                                                                            1. "rows_estimation": [
                                                                                                                                                                                                                                                                                                                                                                                                              1. {
                                                                                                                                                                                                                                                                                                                                                                                                                1. "table": "`s1`",
                                                                                                                                                                                                                                                                                                                                                                                                                  1. "range_analysis": {
                                                                                                                                                                                                                                                                                                                                                                                                                    1. "table_scan": { # 全表扫描的行数以及成本
                                                                                                                                                                                                                                                                                                                                                                                                                      1. "rows": 9688,
                                                                                                                                                                                                                                                                                                                                                                                                                        1. "cost": 2036.7
                                                                                                                                                                                                                                                                                                                                                                                                                          1. } /* table_scan */,
                                                                                                                                                                                                                                                                                                                                                                                                                              1. # 分析可能使用的索引
                                                                                                                                                                                                                                                                                                                                                                                                                                1. "potential_range_indexes": [
                                                                                                                                                                                                                                                                                                                                                                                                                                  1. {
                                                                                                                                                                                                                                                                                                                                                                                                                                    1. "index": "PRIMARY", # 主键不可用
                                                                                                                                                                                                                                                                                                                                                                                                                                      1. "usable": false,
                                                                                                                                                                                                                                                                                                                                                                                                                                        1. "cause": "not_applicable"
                                                                                                                                                                                                                                                                                                                                                                                                                                          1. },
                                                                                                                                                                                                                                                                                                                                                                                                                                            1. {
                                                                                                                                                                                                                                                                                                                                                                                                                                              1. "index": "idx_key2", # idx_key2可能被使用
                                                                                                                                                                                                                                                                                                                                                                                                                                                1. "usable": true,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. "key_parts": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. "key2"
                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. ] /* key_parts */
                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. },
                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. "index": "idx_key1", # idx_key1可能被使用
                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. "usable": true,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. "key_parts": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. "key1",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. "id"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. ] /* key_parts */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. "index": "idx_key3", # idx_key3可能被使用
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. "usable": true,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. "key_parts": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. "key3",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. "id"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. ] /* key_parts */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. "index": "idx_key_part", # idx_keypart不可用
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. "usable": false,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. "cause": "not_applicable"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. ] /* potential_range_indexes */,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. "setup_range_conditions": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. ] /* setup_range_conditions */,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. "group_index_range": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. "chosen": false,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. "cause": "not_group_by_or_distinct"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. } /* group_index_range */,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. # 分析各种可能使用的索引的成本
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. "analyzing_range_alternatives": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. "range_scan_alternatives": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. # 使用idx_key2的成本分析
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. "index": "idx_key2",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. # 使用idx_key2的范围区间
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. "ranges": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. "NULL < key2 < 1000000"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. ] /* ranges */,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. "index_dives_for_eq_ranges": true, # 是否使用index dive
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. "rowid_ordered": false, # 使用该索引获取的记录是否按照主键排序
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. "using_mrr": false, # 是否使用mrr
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. "index_only": false, # 是否是索引覆盖访问
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. "rows": 12, # 使用该索引获取的记录条数
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. "cost": 15.41, # 使用该索引的成本
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. "chosen": true # 是否选择该索引
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. # 使用idx_key1的成本分析
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. "index": "idx_key1",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. # 使用idx_key1的范围区间
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. "ranges": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. "z < key1"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. ] /* ranges */,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. "index_dives_for_eq_ranges": true, # 同上
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. "rowid_ordered": false, # 同上
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. "using_mrr": false, # 同上
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. "index_only": false, # 同上
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. "rows": 266, # 同上
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. "cost": 320.21, # 同上
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. "chosen": false, # 同上
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. "cause": "cost" # 因为成本太大所以不选择该索引
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. # 使用idx_key3的成本分析
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. "index": "idx_key3",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. # 使用idx_key3的范围区间
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. "ranges": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. "a <= key3 <= a",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. "b <= key3 <= b",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. "c <= key3 <= c"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. ] /* ranges */,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. "index_dives_for_eq_ranges": true, # 同上
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. "rowid_ordered": false, # 同上
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. "using_mrr": false, # 同上
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. "index_only": false, # 同上
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. "rows": 21, # 同上
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. "cost": 28.21, # 同上
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. "chosen": false, # 同上
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. "cause": "cost" # 同上
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. ] /* range_scan_alternatives */,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. # 分析使用索引合并的成本
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. "analyzing_roworder_intersect": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. "usable": false,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. "cause": "too_few_roworder_scans"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. } /* analyzing_roworder_intersect */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. } /* analyzing_range_alternatives */,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. # 对于上述单表查询s1最优的访问方法
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. "chosen_range_access_summary": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. "range_access_plan": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. "type": "range_scan",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. "index": "idx_key2",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. "rows": 12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. "ranges": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. "NULL < key2 < 1000000"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. ] /* ranges */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. } /* range_access_plan */,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. "rows_for_plan": 12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. "cost_for_plan": 15.41,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. "chosen": true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. } /* chosen_range_access_summary */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. } /* range_analysis */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. ] /* rows_estimation */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. # 分析各种可能的执行计划
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. #(对多表查询这可能有很多种不同的方案,单表查询的方案上边已经分析过了,直接选取idx_key2就好)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. "considered_execution_plans": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. "plan_prefix": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. ] /* plan_prefix */,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. "table": "`s1`",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. "best_access_path": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. "considered_access_paths": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. "rows_to_scan": 12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. "access_type": "range",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. "range_details": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. "used_index": "idx_key2"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. } /* range_details */,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. "resulting_rows": 12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. "cost": 17.81,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. "chosen": true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. ] /* considered_access_paths */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. } /* best_access_path */,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. "condition_filtering_pct": 100,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. "rows_for_plan": 12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. "cost_for_plan": 17.81,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. "chosen": true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. ] /* considered_execution_plans */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. # 尝试给查询添加一些其他的查询条件
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. "attaching_conditions_to_tables": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. "original_condition": "((`s1`.`key1` > 'z') and (`s1`.`key2` < 1000000) and (`s1`.`key3` in ('a','b','c')) and (`s1`.`common_field` = 'abc'))",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. "attached_conditions_computation": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. ] /* attached_conditions_computation */,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. "attached_conditions_summary": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. "table": "`s1`",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. "attached": "((`s1`.`key1` > 'z') and (`s1`.`key2` < 1000000) and (`s1`.`key3` in ('a','b','c')) and (`s1`.`common_field` = 'abc'))"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. ] /* attached_conditions_summary */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. } /* attaching_conditions_to_tables */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. # 再稍稍的改进一下执行计划
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. "refine_plan": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. "table": "`s1`",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. "pushed_index_condition": "(`s1`.`key2` < 1000000)",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. "table_condition_attached": "((`s1`.`key1` > 'z') and (`s1`.`key3` in ('a','b','c')) and (`s1`.`common_field` = 'abc'))"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. ] /* refine_plan */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. ] /* steps */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. } /* join_optimization */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. "join_execution": { # execute阶段
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. "select#": 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. "steps": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1. ] /* steps */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. } /* join_execution */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. ] /* steps */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1. # 因优化过程文本太多而丢弃的文本字节大小,值为0时表示并没有丢弃
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1. MISSING_BYTES_BEYOND_MAX_MEM_SIZE: 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              1. # 权限字段
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1. INSUFFICIENT_PRIVILEGES: 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. 1 row in set (0.00 sec)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1.  

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  上面其实这只是优化器执行过程中的一小部分,MySQL可能会在之后的版本中添加更多的优化过程信息。不过杂乱之中其实还是蛮有规律的,优化过程大致分为了三个阶段:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • prepare阶段

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • optimize阶段

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • execute阶段

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  我们所说的基于成本的优化主要集中在optimize阶段,对于单表查询来说,我们主要关注optimize阶段的"rows_estimation"这个过程,这个过程深入分析了对单表查询的各种执行方案的成本;对于多表连接查询来说,我们更多需要关注"considered_execution_plans"这个过程,这个过程里会写明各种不同的连接方式所对应的成本。反正优化器最终会选择成本最低的那种方案来作为最终的执行计划,也就是我们使用EXPLAIN语句所展现出的那种方案。

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  文章知识点与官方知识档案匹配,可进一步学习相关知识
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MySQL入门技能树查询优化SHOW STATUS58201 人正在系统学习中

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [转帖]深入理解mysql-第十二章 mysql查询优化-Explain 详解(下)的更多相关文章

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. “全栈2019”Java异常第二十二章:try-with-resources语句详解

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java异 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  2. “全栈2019”Java异常第十五章:异常链详解

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java异 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  3. “全栈2019”Java第九十四章:局部内部类详解

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java第 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  4. MySQL慢查询优化 EXPLAIN详解

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            我们平台过一段时间就会把生产数据库的慢查询导出来分析,要嘛修改写法,要嘛新增索引.以下是一些笔记.总结整理 慢查询排查         show status;  // 查询mysql ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  5. mysql系列十二、mysql常用hint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    对于经常使用oracle的朋友可能知道,oracle的hint功能种类很多,对于优化sql语句提供了很多方法.同样,在mysql里,也有类似的hint功能.下面介绍一些常用的. 强制索引 FORCE ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  6. 第十二章 MySQL触发器(待续)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ······

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  7. 深入理解计算机系统 第十二章 并发编程 part1 第二遍

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    三种构造并发程序的方法及其优缺点 1.进程 用这种方法,每个逻辑控制流都是一个进程,由内核来调度和维护.因为进程有独立的虚拟地址空间,想要和其他流通信,控制流必须使用某种显式的进程间通信机制. 优点: ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  8. 第十二章:Android数据存储(下)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    一.SQLite介绍 提到数据存储问题,数据库是不得不提的.数据库是用来存储关系型数据的不二利器.Android为开发者提供了强大的数据库支持,可以用来轻松地构造基于数据库的应用.Android的数据 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  9. 第十二课:Sizzle引擎详解

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    这篇博客难度太大,跟前端开发其实没什么关系,如果你想成为大牛,那就去了解下吧.如果你还不想,那可以忽略,毕竟面试官也不会问到这里来,因为他也不太懂.呵呵. Sizzle引擎是jQuery的选择器,它大 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  10. Vue.js 源码分析(二十二) 指令篇 v-model指令详解

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Vue.js提供了v-model指令用于双向数据绑定,比如在输入框上使用时,输入的内容会事实映射到绑定的数据上,绑定的数据又可以显示在页面里,数据显示的过程是自动完成的. v-model本质上不过是语 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  随机推荐

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. 昇腾CANN DVPP硬件加速训练数据预处理,友好解决Host CPU预处理瓶

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    本文分享自华为云社区<昇腾CANN 7.0 黑科技:DVPP硬件加速训练数据预处理,友好解决Host CPU预处理瓶颈>,作者: 昇腾CANN . 随着人工智能的快速发展,越来越多的应用场 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  2. 从相识到相惜:Redis与计算存储分离四部曲

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    摘要:协议兼容问题.性能问题.数据备份问题.数据容量问题--这些都是数据库在使用过程中必然会遇见的问题.就好比选择结婚对象,你需要去对比不同的方面,最后选出最好的.最合适的. 近期全国两会正在轰轰烈烈 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  3. Jenkins Pipeline 流水线 - Parameters 参数化构建

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    可以通过参数的方式,指定构建的版本 有两种方式 界面添加 Pipeline Script 脚本配置 (需要Build 一次,然后生效,不知道有没有其它办法) General 界面添加 Pipeline ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  4. Winform 嵌入html,数据交互

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Winform 嵌入html,数据交互,将JS中的数据等传给winform 点击浏览器中的按钮,触发 Winform 中的方法 https://github.com/cefsharp/CefSharp ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  5. 【已解决】Uiautomatorviewer报错:Unexpected error while obtaining UI hierarchy java.lang.reflect.InvocationT...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    报错 使用Uiautomatorviewer连接真机报错Unexpected error while obtaining UI hierarchy (获取UI层次结构时出现意外错误) android8 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  6. 什么是离散化?C++实现方法

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    简介 离散化本质上可以看成是一种 哈希 ,其保证数据在哈希以后仍然保持原来的全/偏序关系. 通俗地讲,就是当我们只关心数据的大小关系时,用排名代替原数据进行处理的一种预处理方法.离散化本质上是一种哈希 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  7. vue tabBar导航栏设计实现1-初步设计

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    系列导航 一.vue tabBar导航栏设计实现1-初步设计 二.vue tabBar导航栏设计实现2-抽取tab-bar 三.vue tabBar导航栏设计实现3-进一步抽取tab-item 四.v ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  8. 4 Englishi 词根

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    11 -ism  N词后缀   ...主义: 流派: 特性 individualism captitalism modernism humanism 12 -ist N词后缀  人: ...家 art ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  9. 机器学习笔记(二)使用paddlepaddle,再探波士顿房价预测

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    目标 用paddlepaddle来重写之前那个手写的梯度下降方案,简化内容 流程 实际上就做了几个事: 数据准备:将一个批次的数据先转换成nparray格式,再转换成Tensor格式 前向计算:将一个 ...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  10. 你做的 9 件事表明你不是专业的 Python 开发人员

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    本文转载自国外论坛 medium,原文地址: https://medium.com/navan-tech/7-java-features-you-might-not-have-heard-of-ade ...