精华内容
下载资源
问答
  • ​ SQL查询中用到的关键词:select、distinct、from、join、on、where、group by、having、sum、count、max、avg、order by、limit书写顺序:​ select->distinct->from->join->on->where->group ...

    ​ SQL查询中用到的关键词:select、distinct、from、join、on、where、group by、having、sum、count、max、avg、order by、limit

    书写顺序:

    ​ select->distinct->from->join->on->where->group by->having->order by->limit

    ​ 必须字段:select、from

    ​ 可选字段:distinct、join、on、where、group by、having、sum、count、max、avg、order by、limit

    执行顺序

    ​ from->on->join->where->group by(开始使用select中的别名,后面的语句中都可以使用别名)->sum、count、max、avg->having->select->distinct->order by->limit

    关键词含义from:需要从哪个数据表检索数据

    join:对需要关联查询的表进行关联

    ​ 关联查询时,数据库会选择一个驱动表,然后用此表的记录去关联其他表

    ​ left join一般以左表为驱动表(right join一般为右表),inner join一般以结果集少的表为驱动表,left join某些情况下会被查询优化器优化为inner join驱动表选择原则:在对最终结果集没影响的前提下,优先选择结果集最少的那张表作为驱动表

    在使用索引关联的情况下,有Index Nested-Loop join和Batched Key Access join两种算法

    在未使用索引关联的情况下,有Simple Nested-Loop join和Block Nested-Loop join两种算法

    Simple Nested-Loop join(SNLJ,简单嵌套循环连接)算法:根据on条件,从驱动表取一条数据,然后全表扫面被驱动表,将符合条件的记录放入最终结果集中。这样驱动表的每条记录都伴随着被驱动表的一次全表扫描匹配次数:外层表行数*内层表行数

    Index Nested-Loop Join(INLJ,索引嵌套循环连接)算法:索引嵌套循环连接是基于索引进行连接的算法,索引是基于内层表的,通过外层表匹配条件直接与内层表索引进行匹配,避免和内层表的每条记录进行比较, 从而利用索引的查询减少了对内层表的匹配次数匹配次数:外层表行数*内层表索引高度

    Block Nested-Loop Join(BNLJ,缓存块嵌套循环连接)算法:缓存块嵌套循环连接通过一次性缓存多条数据,把参与查询的列缓存到Join Buffer 里,然后拿join buffer里的数据批量与内层表的数据进行匹配,从而减少了内层循环的次数(遍历一次内层表就可以批量匹配一次Join Buffer里面的外层表数据)。

    当不使用Index Nested-Loop Join的时候,默认使用Block Nested-Loop Join

    Batched Key Access join(BKAJ)算法:和SNLJ算法类似,但用于被join表上有索引可以利用,那么在行提交给被join的表之前,对这些行按照索引字段进行排序,因此减少了随机IO,排序这才是两者最大的区别,但是如果被join的表没用索引呢?那就使用BNLJ了

    什么是Join Buffer?Join Buffer会缓存所有参与查询的列而不是只有Join的列。

    可以通过调整join_buffer_size缓存大小

    join_buffer_size的默认值是256K,join_buffer_size的最大值在MySQL 5.1.22版本前是4G,而之后的版本才能在64位操作系统下申请大于4G的Join Buffer空间。

    使用Block Nested-Loop Join算法需要开启优化器管理配置的optimizer_switch的设置block_nested_loop为on,默认为开启。

    在选择Join算法时,会有优先级,理论上会优先判断能否使用INLJ、BNLJ:

    Index Nested-LoopJoin > Block Nested-Loop Join > Simple Nested-Loop Join

    注:可以使用explain查找驱动表,结果的第一张表即为驱动表,但执行计划在真正执行时可能发生改变

    on:关联条件

    where:过滤表中数据的条件执行顺序:自下而上、从右到左

    注:对数据库记录生效,无法对聚合结果生效,可以过滤掉最大数量记录的条件必须写在where子句末尾,不能使用聚合函数(sum、count、max、avg)

    group by:如何将上面过滤出的数据分组执行顺序:从左往右

    注:尽量在group by之前使用where过滤,避免之后使用having过滤

    avg:求平均值

    having:对上面已经分组的数据进行过滤的条件注:对聚合结果过滤,因此很耗资源,可以使用聚合函数

    例:筛选统计人口数量大于100W的地区

    ​ select region, sum(population), sum(area) from bbc group by region having sum(population)>1000000,不能用where筛选超过100W的地区,因为不存在这样的一条记录

    select:查看结果集中的哪个列或列的计算结果

    distinct:对结果集重复值去重

    order by:按照什么样的顺序来查看返回的数据执行顺序:从左到右

    注:很耗资源

    limit:截取出目标页数据

    展开全文
  • 先构建本篇博客的案列演示:create table a(a1 int primary key, a2 int ,index(a2)); --双字段都有索引create table c(c1 int primary key, c2 int ,index(c2), c3 int); --双字段都有索引create table b(b1 int ...

    先构建本篇博客的案列演示表:

    create table a(a1 int primary key, a2 int ,index(a2)); --双字段都有索引

    create table c(c1 int primary key, c2 int ,index(c2), c3 int); --双字段都有索引

    create table b(b1 int primary key, b2 int);--有主键索引

    create table d(d1 int, d2 int); --没有索引

    insert into a values(1,1),(2,2),(3,3),(4,4),(5,5),(6,6),(7,7),(8,8),(9,9),(10,10);

    insert into b values(1,1),(2,2),(3,3),(4,4),(5,5),(6,6),(7,7),(8,8),(9,9),(10,10);

    insert into c values(1,1,1),(2,4,4),(3,6,6),(4,5,5),(5,3,3),(6,3,3),(7,2,2),(8,8,8),(9,5,5),(10,3,3);

    insert into d values(1,1),(2,2),(3,3),(4,4),(5,5),(6,6),(7,7),(8,8),(9,9),(10,10);

    驱动表如何选择?

    驱动表的概念是指多表关联查询时,第一个被处理的表,使用此表的记录去关联其他表。驱动表的确定很关键,会直接影响多表连接的关联顺序,也决定了后续关联时的查询性能。

    驱动表的选择遵循一个原则:在对最终结果集没影响的前提下,优先选择结果集最小的那张表作为驱动表。改变驱动表就意味着改变连接顺序,只有在不会改变最终输出结果的前提下才可以对驱动表做优化选择。在外连接情况下,很多时候改变驱动表会对输出结果有影响,比如left join的左边表和right join的右边表,驱动表选择join的左边或者右边最终输出结果很有可能会不同。

    用结果集来选择驱动表,那结果集是什么?如何计算结果集?mysql在选择前会根据where里的每个表的筛选条件,相应的对每个可作为驱动表的表做个结果记录预估,预估出每个表的返回记录行数,同时再根据select里查询的字段的字节大小总和做乘积:

    每行查询字节数 * 预估的行数 = 预估结果集

    通过where预估结果行数,遵循以下规则:

    如果where里没有相应表的筛选条件,无论on里是否有相关条件,默认为全表

    如果where里有筛选条件,但是不能使用索引来筛选,那么默认为全表

    如果where里有筛选条件,而且可以使用索引,那么会根据索引来预估返回的记录行数

    我们以上述创建的表为基础,用如下sql作为案列来演示:

    select a.*,c.c2 from a join c on a.a2=c.c2 where a.a1>5 and c.c1>5;

    通过explain查看其执行计划:

    b14dab5bb03160d1e734c544fbaa52ae.png

    explain显示结果里排在第一行的就是驱动表,此时表a为驱动表。

    如果将sql修改一下,将select 里的条件c.c2 修改为 c.* :

    select a.*,c.* from a join c on a.a2=c.c2 where a.a1>5 and c.c1>5;

    通过explain查看其执行计划:

    6958c1b4987c6c232c349941722f288c.png

    此时驱动表还是c,按理来说 c.* 的数据量肯定是比 a.*大的,似乎结果集大小的规则在这里没有起作用。

    此情形下如果用a作为驱动表,通过索引c2关联到c表,那么还需要再回表查询一次,因为仅仅通过c2获取不到c.*的数据,还需要通过c2上的主键c1再查询一次。而上一个sql查询的是c2,不需要额外查询。同时因为a表只有两个字段,通过a2索引能够直接获得a.*,不需要额外查询。

    综上所述,虽然使用c表来驱动,结果集大一些,但是能够减少一次额外的回表查询,所以mysql认为使用c表作为驱动来效率更高。

    结果集是作为选择驱动表的一个主要因素,但不是唯一因素。

    2 . 两表关联查询的内在逻辑是怎样的?

    mysql表与表之间的关联查询使用Nested-Loop join算法,顾名思义就是嵌套循环连接,但是根据场景不同可能有不同的变种:比如Index Nested-Loop join,Simple Nested-Loop join,Block Nested-Loop join, Betched Key Access join等。

    在使用索引关联的情况下,有Index Nested-Loop join和Batched Key Access join两种算法;

    在未使用索引关联的情况下,有Simple Nested-Loop join和Block Nested-Loop join两种算法;

    我们先来看有索引的情形,使用的是博客刚开始时建立的表,sql如下:

    select a.*,c.* from a join c on a.a2=c.c2 where a.a1>4;

    通过explain查看其执行计划:

    6c017c20607fafcffbd8d099bcd14fab.png

    首先根据第一步的逻辑来确定驱动表a,然后通过a.a1>4,a.来查询一条记录a1=5,将此记录的c2关联到c表,取得c2索引上的主键c1,然后用c1的值再去聚集索引上查询c.*,组成一条完整的结果,放入net buffer,然后再根据条件a.a1>4,a. 取下一条记录,循环此过程。过程图如下:

    e61b450893493fdc484b31bb738b7745.png

    通过索引关联被驱动表,使用的是Index Nested-Loop join算法,不会使用msyql的join buffer。根据驱动表的筛选条件逐条地和被驱动表的索引做关联,每关联到一条符合的记录,放入net-buffer中,然后继续关联。此缓存区由net_buffer_length参数控制,最小4k,最大16M,默认是1M。 如果net-buffer满了,将其发送给client,清空net-buffer,继续上一过程。

    通过上述流程知道,驱动表的每条记录在关联被驱动表时,如果需要用到索引不包含的数据时,就需要回表一次,去聚集索引上查询记录,这是一个随机查询的过程。每条记录就是一次随机查询,性能不是非常高。mysql对这种情况有选择的做了优化,将这种随机查询转换为顺序查询,执行过程如下图:

    339d0f62b73e388c9005145495573ab3.png

    此时会使用Batched Key Access join 算法,顾名思义,就是批量的key访问连接。

    逐条的根据where条件查询驱动表,将符合记录的数据行放入join buffer,然后根据关联的索引获取被驱动表的索引记录,存入read_rnd_buffer。join buffer和read_rnd_buffer都有大小限制,无论哪个到达上限都会停止此批次的数据处理,等处理完清空数据再执行下一批次。也就是驱动表符合条件的数据可能不能够一次处理完,而要分批次处理。

    当达到批次上限后,对read_rnd_buffer里的被驱动表的索引按主键做递增排序,这样在回表查询时就能够做到近似顺序查询:

    0857b4d1a08d7c3b7a146eae5ac9b4db.png

    a5f29ca378d9ea4d8fee47da58580a10.png

    如上图,左边是未排序前的随机查询示意图,右边是排序后使用MRR(Multi-Range Read)的顺序查询示意图。

    因为mysql的InnoDB引擎的数据是按聚集索引来排列的,当对非聚集索引按照主键来排序后,再用主键去查询就使得随机查询变为顺序查询,而计算机的顺序查询有预读机制,在读取一页数据时,会向后额外多读取最多1M数据。此时顺序读取就能排上用场。

    BKA算法在需要对被驱动表回表的情况下能够优化执行逻辑,如果不需要会表,那么自然不需要BKA算法。

    如果要使用 BKA 优化算法的话,你需要在执行 SQL 语句之前先设置:

    set optimizer_switch='mrr=on,mrr_cost_based=off,batched_key_access=on';

    前两个参数的作用是要启用 MRR(Multi-Range Read)。这么做的原因是,BKA 算法的优化需要依赖于MRR,官方文档的说法,是现在的优化器策略,判断消耗的时候,会更倾向于不使用 MRR,把 mrr_cost_based 设置为 off,就是固定使用 MRR 了。)

    最后再用explain查看开启参数后的执行计划:

    429213.html

    上述都是有索引关联被驱动表的情况,接下来我们看看没有索引关联被驱动表的情况。

    没有使用索引关联,那么最简单的Simple Nested-Loop join,就是根据where条件,从驱动表取一条数据,然后全表扫面被驱动表,将符合条件的记录放入最终结果集中。这样驱动表的每条记录都伴随着被驱动表的一次全表扫描,这就是Simple Nested-Loop join。

    当然mysql没有直接使用Simple Nested-Loop join,而是对其做了一个优化,不是逐条的获取驱动表的数据,而是多条的获取,也就是一块一块的获取,取名叫Block Nested-Loop join。每次取一批数据,上限是达到join buffer的大小,然后全表扫面被驱动表,每条数据和join buffer里的所有行做匹配,匹配上放入最终结果集中。这样就极大的减少了扫描被驱动表的次数。

    BNL(Block Nested-Loop join) 和 BKA(Batched Key Access join)的流程有点类似, 但是没有read_rnd_buffer这个步骤。

    示例sql如下:

    select a.*, d.* from a join d on a.a2=d.d2 where a.a1>7;

    用explain查看其执行计划:

    3517572b568b8a7158e2fa949bd69dd4.png

    3 . 多表连接如何执行?是先两表连接的结果集然后关联第三张表,还是一条记录贯穿全局?

    其实看连接算法的名称:Nested-Loop join,嵌套循环连接,就知道是多表嵌套的循环连接,而不是先两表关联得出结果,然后再依次关联的形式,其形式类似于下面这样:

    for row1 in table1 filtered by where{

    for row2 in table2 associated by table1.index1 filtered by where{

    for row3 in table3 associated by table2.index2 filtered by where{

    put into net-buffer then send to client;

    }

    }

    }

    对于不同的join方式,有下列情况:

    Index Nested-Loop join:

    sql如下:

    select a.*,b.*,c.* from a join c on a.a2=c.c2 join b on c.c2=b.b2 where b.b1>4;

    通过explain查看其执行计划:

    fe0c3c8ede36e1f5ea2375cd12fdcdd0.png

    其内部执行流程如下:

    b69103309558401731629a3ae371399f.png

    执行前mysql执行器会确定好各个表的关联顺序。首先通过where条件,筛选驱动表b的第一条记录b5,然后将用此记录的关联字段b2与第二张表a的索引a2做关联,通过Btree定位索引位置,匹配的索引可能不止一条。当匹配上一条,查看where里是否有a2的过滤条件且条件是否需要索引之外的数据,如果要则回表,用a2索引上的主键去查询数据,然后做判断。通过则用join后的信息再用同样的方式来关联第三章表c。

    Block Nested-Loop join 和 Batched Key Access join : 这两个关联算法和Index Nested-Loop join算法类似,不过因为他们能使用join buffer,所以他们可以每次从驱动表筛选一批数据,而不是一条。同时每个join关键字就对应着一个join buffer,也就是驱动表和第二张表用一个join buffer,得到的块结果集与第三章表用一个join buffer。

    本篇博客主要就是讲述上述三个问题,如何确定驱动表,两表关联的执行细节,多表关联的执行流程。

    有疑问欢迎留言,共同进步。

    展开全文
  • 当前位置:我的异常网» Oracle技术»表连接与where条件执行先后顺序解决思路表连接...在oracle中,多表连接的时候,怎么加hint条件,使oracle按照设定的顺序进行表连接。2.表连接的时候,大表与小表的顺序是哪个在前...

    当前位置:我的异常网» Oracle技术 » 表连接与where条件执行先后顺序解决思路

    表连接与where条件执行先后顺序解决思路

    www.myexceptions.net  网友分享于:2013-04-04  浏览:408次

    表连接与where条件执行先后顺序

    1.在oracle中,多表连接的时候,怎么加hint条件,使oracle按照设定的顺序进行表连接。

    2.表连接的时候,大表与小表的顺序是哪个在前.

    3.在多表连接时,是表与表先连接起来,再执行对单表的限制条件where条件;还是先执行单表的限制where条件,再进行表连接?

    4.多表连接时,如4个表,我自己做了一个实验:4个表连接执行查询vs2个表查询放入临时表再关联到一起查询。结果是后者的效率更高些。没有想通是问什么,按道理,后者有更多的io耗费呀!

    以上问题,求解...

    ------解决方案--------------------

    oracle中Where子句的条件顺序对性能的影响:

    经常有人问到oracle中的Where子句的条件书写顺序是否对SQL性能有影响,我的直觉是没有影响,因为如果这个顺序有影响,Oracle应该早就能够做到自动优化,但一直没有关于这方面的确凿证据。在网上查到的文章,一般认为在RBO优化器模式下无影响(10G开始,缺省为RBO优化器模式),而在CBO优化器模式下有影响,主要有两种观点:

    a.能使结果最少的条件放在最右边,SQL执行是按从右到左进行结果集的筛选的;

    b.有人试验表明,能使结果最少的条件放在最左边,SQL性能更高。

    查过oracle8到11G的在线文档,关于SQL优化相关章节,没有任何文档说过where子句中的条件对SQL性能有影响,到底哪种观点是对的,没有一种确切的结论,只好自己来做实验证明。结果表明,SQL条件的执行是从右到左的,但条件的顺序对SQL性能没有影响。

    实验一:证明了SQL的语法分析是从右到左的

    下面的试验在9i和10G都可以得到相同的结果: 第1条语句执行不会出错,第2条语句会提示除数不能为零。

    1.Select 'ok' From Dual Where 1 / 0 = 1 And 1 = 2;

    2.Select 'ok' From Dual Where 1 = 2 And 1 / 0 = 1;

    证明了SQL的语法分析是从右到左的。

    实验二:证明了SQL条件的执行是从右到左的

    drop table temp;

    create table temp( t1 varchar2(10),t2 varchar2(10));

    insert into temp values('zm','abcde');

    insert into temp values('sz','1');

    insert into temp values('sz','2');

    commit;

    1. select * from temp where to_number(t2)>1 and t1='sz';

    2. select * from temp where t1='sz' and to_number(t2)>1;

    在9i上执行, 第1条语句执行不会出错,第2条语句会提示“无效的数字”

    在10G上执行,两条语句都不会出错。

    说明:9i上,SQL条件的执行确实是从右到左的,但是10G做了什么调整呢?

    实验三:证明了在10g上SQL条件的执行是从右到左的

    Create Or Replace Function F1(v_In Varchar2) Return Varchar2 Is

    Begin

    Dbms_Output.Put_Line('exec F1');

    Return v_In;

    End F1;

    /

    Create Or Replace Function F2(v_In Varchar2) Return Varchar2 Is

    Begin

    Dbms_Output.Put_Line('exec F2');

    Return v_In;

    End F2;

    /

    SQL> set serverout on;

    SQL> select 1 from dual where f1('1')='1' and f2('1')='1';

    1

    ----------

    1

    exec F2

    exec F1

    SQL> select 1 from dual where f2('1')='1' and f1('1')='1';

    1

    ----------

    1

    exec F1

    exec F2

    结果表明,SQL条件的执行顺序是从右到左的。

    那么,根据这个结果来分析,把能使结果最少的条件放在最右边,是否会减少其它条件执行时所用的记录数量,从而提高性能呢?

    例如:下面的SQL条件,是否应该调整SQL条件的顺序呢?

    Where A.结帐id Is Not Null

    And A.记录状态<>0

    And A.记帐费用=1

    And (Nvl(A.实收金额, 0)<>Nvl(A.结帐金额, 0) Or Nvl(A.结帐金额, 0)=0)

    And A.病人ID=[1] And Instr([2],','||Nvl(A.主页ID,0)||',')>0

    And A.登记时间Between [3] And [4]

    And A.门诊标志<>1

    实际上,从这条SQL语句的执行计划来分析,Oracle首先会找出条件中使用索引或表间连接的条件,以此来过滤数据集,然后对这些结果数据块所涉及的记录逐一检查是否符合所有条件,所以条件顺序对性能几乎没有影响。

    Create Or Replace Function F1(v_In Varchar2) Return Varchar2 Is

    Begin

    Dbms_Output.Put_Line('exec F1');

    Return v_In;

    End F1;

    /

    Create Or Replace Function F2(v_In Varchar2) Return Varchar2 Is

    Begin

    Dbms_Output.Put_Line('exec F2');

    Return v_In;

    End F2;

    /

    SQL> set serverout on;

    SQL> select 1 from dual where f1('1')='1' and f2('1')='1';

    1

    ----------

    1

    exec F2

    exec F1

    SQL> select 1 from dual where f2('1')='1' and f1('1')='1';

    1

    ----------

    1

    exec F1

    exec F2

    结果表明,SQL条件的执行顺序是从右到左的。

    那么,根据这个结果来分析,把能使结果最少的条件放在最右边,是否会减少其它条件执行时所用的记录数量,从而提高性能呢?

    例如:下面的SQL条件,是否应该调整SQL条件的顺序呢?

    文章评论

    展开全文
  • mysql对多表关联查询使用Nested-Loop Join算法,简单总结就是通过驱动表作为入口,一层层的往内部查询,驱动表的数据量对查询效率很关键。而对驱动表的选择,from后的表顺序并不起决定作用,mysql会根据多重因素选择...

    mysql对多表关联查询使用Nested-Loop Join算法,简单总结就是通过驱动表作为入口,一层层的往内部查询,驱动表的数据量对查询效率很关键。

    而对驱动表的选择,from后的表顺序并不起决定作用,mysql会根据多重因素选择最优的链接顺序。如果想自行控制链接顺序可以通过Optimizer Hints(mysql 8.0)指定。

    使用saklia数据库

    1.先通过一个left join的例子说明from后的表顺序对实际执行时的关联顺序不起决定作用的现象

    explain

    select a.rental_id, a.rental_date,b.film_id

    from rental a left join inventory b on a.inventory_id = b.inventory_id

    42e04b853f10746fb994e7c1783db8f7.png

    可以看到执行顺序是a>b

    2.接下来,我们调换一下表的顺序

    explain

    select a.rental_id, a.rental_date,b.film_id

    from inventory b left join rental a on a.inventory_id = b.inventory_id

    77929aacd19d2f12867d34b3e9781f93.png

    从explain输出结果看,b确实到前面去了,变成了b>a

    3.还没结束接着看,我们带上a的一个条件

    explain

    select a.rental_id, a.rental_date,b.film_id

    from inventory b left join rental a on a.inventory_id = b.inventory_id

    where a.rental_date >= '2005-01-19 02:18:51';

    e261f509a1ece09dc83b268de2de7284.png

    看到顺序又变成了a>b,此sql并未改变from表的顺序,只是增加了a的过滤条件

    4.如果就是想将b放到第一个驱动表的位置,可以通过Optimizer Hints的JOIN_PREFIX指定

    explain

    select /*+JOIN_PREFIX(b) */ a.rental_id, a.rental_date,b.film_id

    from inventory b left join rental a on a.inventory_id = b.inventory_id

    where a.rental_date >= '2005-01-19 02:18:51';

    f6fdaba082997f4704cd874f97a7872e.png

    不过JOIN_PREFIX只有mysql8.0才有,5.7并没有。除了JOIN_PREFIX还有JOIN_FIXED_ORDER、JOIN_ORDER、JOIN_SUFFIX用来指定表链接顺序

    更多Optimizer Hints信息可到官网查看https://dev.mysql.com/doc/refman/8.0/en/optimizer-hints.html

    展开全文
  • Oracle sql语句执行顺序

    2021-05-01 05:12:12
    sql语法的分析是从右到左一、sql语句的执行步骤:1)语法分析,分析语句的语法是否符合规范,衡量语句中各表达式的意义。...5)选择优化器,不同的优化器一般产生不同的“执行计划”6)选择连接方式,...
  • 当shell需要一次执行多个命令的时候,命令之间需要用连接连接,不同的连接符有不同的效果。1、命令之间用; 顺序符隔开; 分号,没有任何逻辑关系的连接符。各命令之间的执行成功与否彼此没有任何影响,都会一条一条...
  • 执行顺序:先执行on and条件,再执行where条件具体是:首先根据on and条件过滤出满足条件的右侧记录,然后根据关联字段,左侧再与过滤出的右侧记录进行连接,满足关联字段相等,则返回左侧和右侧表字段信息...
  • Hive SQL语句的正确执行顺序

    千次阅读 2021-07-28 08:53:16
    关于 sql 语句的执行顺序网上有很资料,但是大多都没进行验证,并且很都有点小错误,尤其是对于 select 和 group by 执行的先后顺序,有说 select 先执行,有说 group by 先执行,到底它俩谁先执行呢?...
  • MySQL,SQL语句执行顺序

    千次阅读 2021-01-19 16:30:59
    1.SQL执行顺序:select 考生姓名, max(总成绩) asmax总成绩fromtb_Gradewhere 考生姓名 is not nullgroup by考生姓名having max(总成绩) > 600order by max总成绩(1). 首先执行 FROM 子句, 从 tb_Grade 组装...
  • 上一篇讲述了Oracle的SELECT语法的执行顺序,这篇讲述MySQL的SELECT语法的执行顺序。MySQL的SELECT语法的执行顺序和Oracle的基本相同,只是增加了MySQL独有的LIMIT语法。目录一、SELECT语句的处理过程1、 FROM阶段2...
  • MySQL的语句执行顺序

    2021-01-19 05:19:04
    下面我们来具体分析一下查询处理的每一个阶段MySQL的语句一共分为11步,如下图所标注的那样,最先执行的总是FROM操作,最后执行的是LIMIT操作。其中每一个操作都会产生一张虚拟的,这个虚拟的作为一个处理的输入...
  • 在 Bash 中,如果需要让条命令顺序执行,则有这样方法,如 1 所示。 1 命令顺序执行的方法命令执行符格 式作 用;命令1 ; 命令2条命令顺序执行,命令之间没有任何逻辑关系&&命令1 && ...
  • 一、典型SELECT语句完整的执行顺序1)from子句组装来自不同数据源的数据;2)使用on进行join连接的数据筛选3)where子句基于指定的条件对记录行进行筛选;4)group by子句将数据划分为个分组;5)cube, rollup6)使用...
  • Mysql存储过程的执行顺序问题SQL code:CREATE TABLE `t_a` (`a_id` int(11) NOT NULL AUTO_INCREMENT,`a_name` varchar(30) NOT NULL DEFAULT 'N/A',PRIMARY KEY (`a_id`)) ENGINE=MyISAM DEFAULT CHARSET=utf8;...
  • 目录 1.SELECT语句处理顺序 2.where 后条件执行先后顺序 1.SELECT语句处理顺序 (1)from ...(5)group by (开始使用select中的别名,后面...第一步:首先对from子句中的前两个表执行一个笛卡尔乘积,此时生成虚拟vt1
  • sql 查询语句执行顺序

    千次阅读 2021-05-29 20:50:09
    了解 sql 的执行顺序是很必要的,执行顺序不同可能查询到的结果最后也会不一样。 select 语句的完整语法如下: SELECT    DISTINCT < select_field >   FROM < ...
  • 在一些大的公司里面,都会禁用多表连接查询,原因就是一旦数据量足够大的时候多表连接查询效率会很慢,而且不利于分库分表的查询优化。 例: SELECT p.id, sn.name AS nodeName, o.EndTs AS expiryTime, o....
  • join多表连接和group by分组

    千次阅读 2021-02-05 03:20:07
    一、多表连接多表连接的时间是数据库一个非常耗时的操作,因为连接的时间复杂度是M*N(M,N是要连接的表的记录数),如果不对进行优化,连接的产生的临时表可能非常大,需要写入磁盘,分多趟进行处理。1、双表等值join...
  • sql语句 where 后条件执行先后顺序

    千次阅读 2021-01-19 07:02:22
    针对mysql,其条件执行顺序是 从左往右,自上而下针对SQL server、orcale,其条件执行顺序是从右往左,自下而上1.mysqlwhere执行顺序是从左往右执行的,在数据量小的时候不用考虑,但数据量的时候要考虑条件的先后...
  • (3)行子查询【返回一行】 (4)表子查询【返回一个表(也就是多表查询)】 子查询语法【重点】 注意各种查询语句需要分类 from型:【所谓的列子查询、行子查询、表子查询常常是from查询,但是列子查询又是也会做...
  • some summary about hive sql 过程 select * from table 历经下面几个过程: 解析:将SQL字符串解析成语法树AST,判断表示否...Hive 仅仅支持等值连接,on a.id >= b.id 不允许,on a.id = b.id 是可以的。 ...
  • 1. 首先加载mybatis-config.xml总配置文件,根据development的参数配置连接数据库;查询mappers映射关系,找到mapper.xml配置文件。 mybatis-config.xml总配置文件代码 <?xml version="1.0" encoding="UTF-8"?>...
  • 引用地址:https://blog.csdn.net/qq_30349961/article/details/82662550 http://blog.sina.com.cn/s/blog_6ff05a2c01016j7n.html 经常看到一些Hive...提到的原因都是说因为小可以先放到内存中,然后大的每条记录...
  • MySQL多表查询详解

    千次阅读 2021-03-03 19:40:24
    多表查询1. 表与表之间的关系<1> 一对一用户表和身份信息表,用户表是主表男人表、女人表create table man(mid int primary key auto_increment,mname varchar(32),wid int unique);create table woman(wid ...
  • 再举个例子,主容器是nginx,运行前要检测nginx服务器能否连接到mysql服务器和php服务器,那mysql服务器来说,让initcontainer先去检测能否ping通mysql服务器,能ping通则继续运行下一个initcontainer,最后到主容器...
  • 1. 执行命令中间的“分号”代表命令之间没有逻辑关系,分号连接的命令会按照顺序从前向后依次执行,但分号两端的命令之间没有任何逻辑关系,所有写出来的命令最终都会被执行,即使分号前面的命令出错也不影响后面的...
  • 表连接实例3.1 Nest Loop Join3.2 hash join参考: 一. Nested Loop Join算法 1.1 普通的Nested Loop Join算法 将外层的结果集作为循环的基础数据,然后循环从该结果集每次一条获取数据作为下一个的过滤条件去...
  • 内容导航distinct 查询结果去重连接查询连接查询的分类笛卡尔积现象给起别名减少匹配次数内连接--- 等值查询 Java(打卡第六十七天) MySQL数据库连接查询,distinct去重 > DBMS --> SQL ----> DB dbms...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 694,085
精华内容 277,634
关键字:

多表连接执行顺序