精华内容
下载资源
问答
  • mysql where和 join on 哪个效率

    千次阅读 2021-01-18 22:18:24
    的一点提醒ON 条件(“A LEFT JOIN B ON 条件表达式”中的ON)用来决定如何从 B 表中检索数据行,即使on中包含有A表中的列的限制条件,也不会过滤A的任何数据(A的数据只会通过where过滤)。如果 B 表中没有任何一行数据...

    展开全部

    关于 “A LEFT JOIN B ON 条件636f707962616964757a686964616f31333363373666表达式” 的一点提醒

    ON 条件(“A LEFT JOIN B ON 条件表达式”中的ON)用来决定如何从 B 表中检索数据行,即使on中包含有A表中的列的限制条件,也不会过滤A的任何数据(A的数据只会通过where过滤)。

    如果 B 表中没有任何一行数据匹配 ON 的条件,将会额外生成一行所有列为 NULL 的数据

    在匹配阶段 WHERE 子句的条件都不会被使用。仅在匹配阶段完成以后,WHERE 子句条件才会被使用。它将从匹配阶段产生的数据中检索过滤。

    让我们看一个 LFET JOIN 示例:

    01

    mysql> CREATE TABLE `product`

    (

    02

    `id` int(10)

    unsigned NOT NULL auto_increment,

    03

    `amount` int(10)

    unsigned default NULL,

    04

    PRIMARY KEY (`id`)

    05

    )

    ENGINE=MyISAM AUTO_INCREMENT=5 DEFAULT CHARSET=latin1

    06

    07

    mysql> CREATE TABLE `product_details`

    (

    08

    `id` int(10)

    unsigned NOT NULL,

    09

    `weight` int(10)

    unsigned default NULL,

    10

    `exist` int(10)

    unsigned default NULL,

    11

    PRIMARY KEY (`id`)

    12

    )

    ENGINE=MyISAM DEFAULT CHARSET=latin1

    13

    14

    mysql> INSERT INTO product

    (id,amount)

    15

    VALUES (1,100),(2,200),(3,300),(4,400);

    16

    Query

    OK, 4 rows affected

    (0.00 sec)

    17

    Records:

    4 Duplicates: 0 Warnings: 0

    18

    19

    mysql> INSERT INTO product_details

    (id,weight,exist)

    20

    VALUES (2,22,0),(4,44,1),(5,55,0),(6,66,1);

    21

    Query

    OK, 4 rows affected

    (0.00 sec)

    22

    Records:

    4 Duplicates: 0 Warnings: 0

    23

    24

    mysql> SELECT * FROM product;

    25

    +----+--------+

    26

    |

    id | amount |

    27

    +----+--------+

    28

    |

    1 | 100 |

    29

    |

    2 | 200 |

    30

    |

    3 | 300 |

    31

    |

    4 | 400 |

    32

    +----+--------+

    33

    4 rows in set (0.00

    sec)

    34

    35

    mysql> SELECT * FROM product_details;

    36

    +----+--------+-------+

    37

    |

    id | weight | exist |

    38

    +----+--------+-------+

    39

    |

    2 | 22 | 0 |

    40

    |

    4 | 44 | 1 |

    41

    |

    5 | 55 | 0 |

    42

    |

    6 | 66 | 1 |

    43

    +----+--------+-------+

    44

    4 rows in set (0.00

    sec)

    45

    46

    mysql> SELECT * FROM product LEFT JOIN product_details

    47

    ON (product.id

    = product_details.id);

    48

    +----+--------+------+--------+-------+

    49

    |

    id | amount | id | weight | exist |

    50

    +----+--------+------+--------+-------+

    51

    |

    1 | 100 | NULL | NULL | NULL |

    52

    |

    2 | 200 | 2 | 22 | 0 |

    53

    |

    3 | 300 | NULL | NULL | NULL |

    54

    |

    4 | 400 | 4 | 44 | 1 |

    55

    +----+--------+------+--------+-------+

    56

    4 rows in set (0.00

    sec)

    ON 子句和 WHERE 子句有什么不同?

    一个问题:下面两个查询的结果集有什么不同么?

    1

    1. SELECT * FROM product LEFT JOIN product_details

    2

    ON (product.id

    = product_details.id)

    3

    AND product_details.id=2;

    4

    2. SELECT * FROM product LEFT JOIN product_details

    5

    ON (product.id

    = product_details.id)

    6

    WHERE product_details.id=2;

    用例子来理解最好不过了:

    01

    mysql> SELECT * FROM product LEFT JOIN product_details

    02

    ON (product.id

    = product_details.id)

    03

    AND product_details.id=2;

    04

    +----+--------+------+--------+-------+

    05

    |

    id | amount | id | weight | exist |

    06

    +----+--------+------+--------+-------+

    07

    |

    1 | 100 | NULL | NULL | NULL |

    08

    |

    2 | 200 | 2 | 22 | 0 |

    09

    |

    3 | 300 | NULL | NULL | NULL |

    10

    |

    4 | 400 | NULL | NULL | NULL |

    11

    +----+--------+------+--------+-------+

    12

    4 rows in set (0.00

    sec)

    13

    14

    mysql> SELECT * FROM product LEFT JOIN product_details

    15

    ON (product.id

    = product_details.id)

    16

    WHERE product_details.id=2;

    17

    +----+--------+----+--------+-------+

    18

    |

    id | amount | id | weight | exist |

    本回答由提问者推荐

    2Q==

    已赞过

    已踩过<

    你对这个回答的评价是?

    评论

    收起

    展开全文
  • Oracle中Left joinon和where效率差别,在linq中使用into rightRow from rw in rightRow.DefaultIfEmpty()可以保证查询类型le假设有两个表a、b使用onSelect * from a left join b on b.col = a.col and b.col2 = ...

    Oracle中Left join的on和where的效率差别,在linq中使用into rightRow from rw in rightRow.DefaultIfEmpty()可以保证查询类型le

    假设有两个表a、b

    使用on

    Select * from a left join b on b.col = a.col and b.col2 = ‘aa’

    使用 where

    Select * from a left join b on b.col = a.col where b.col2 = ‘aa’ and b.col2 is null

    // b.col2 is null作用是防止因b表中没有匹配数据,照成a表原有记录无法返回的问题

    分析

    1、on条件是在生成临时表时使用的条件,它不管on中的条件是否为真,都会返回左边表中的记录。

    2、where条件是在临时表生成好后,再对临时表进行过滤的条件。这时已经没有left join的含义(必须返回左边表的记录)了,条件不为真的就全部过滤掉。

    语句测试

    set serveroutput on ; -- 必须运行,否则打印结果无法显示

    declare

    I Number;

    Starttime Timestamp;

    Endtime Timestamp;

    Begin

    select current_timestamp(5) into starttime from Dual;

    I := 1;

    While I<=10000 Loop

    dbms_output.put_line(i);

    Execute Immediate ' '; --此处放入sql语句

    i := i+1;

    End Loop;

    Select Current_Timestamp(5) Into Endtime From Dual;

    dbms_output.put_line('10000条语句运行时间为(毫秒):' || (endtime - starttime)); --打印一个Interval类型数据,显示时间差

    end;

    测试结果

    On语句, 10000条语句运行时间为(毫秒):+000000000 00:00:01.032850000

    Where 语句 10000条语句运行时间为(毫秒):+000000000 00:00:01.013420000

    结论

    Where语句的性能优于on语句

    其实sql语句的运行效率也可以通过查询Oracle的系统视图来查看,,但时间关系今后再研究了。

    在C#中使用linq进行查询

    // 写得比较仓促,见谅了

    var reList = from DataRow a in dtA.Rows

    join DataRow b in dtB.Rows on

    new {t = a["col"], l=’aa’}

    equals

    new {t = b["col"], l = b["col2"] }

    into rightRow from rw in rightRow.DefaultIfEmpty()

    select new

    {

    Col1 = a["col"],

    Col2 = rw["col2"]

    };

    在linq中使用into rightRow from rw in rightRow.DefaultIfEmpty()可以保证查询类型left outer join的效果,如果left join中有多个查询条件,使用new两个对象进行比较即可。

    logo.gif

    f68f2add0b68e4f9810432fce46917b7.png

    本文原创发布php中文网,转载请注明出处,感谢您的尊重!

    展开全文
  • 对于要达到同一查询结果而言,join和where的用法是语句格式不一样,查询的结果是一样的。先来看看join的语句分类:left join :左连接,返回左表中所有的记录以及右表中连接字段相等的记录。right join :右连接,返回...

    对于要达到同一查询结果而言,join和where的用法是语句格式不一样,查询的结果是一样的。

    先来看看join的语句分类:

    left join :左连接,返回左表中所有的记录以及右表中连接字段相等的记录。

    right join :右连接,返回右表中所有的记录以及左表中连接字段相等的记录。

    inner join: 内连接,又叫等值连接,只返回两个表中连接字段相等的行。

    full join:外连接,返回两个表中的行:left join + right join。

    cross join:结果是笛卡尔积,就是第一个表的行数乘以第二个表的行数。

    关键字: on

    数据库在通过连接两张或多张表来返回记录时,都会生成一张中间的临时表,然后再将这张临时表返回给用户。

    在使用left jion时,on和where条件的区别如下:

    1、 on条件是在生成临时表时使用的条件,它不管on中的条件是否为真,都会返回左边表中的记录。

    2、where条件是在临时表生成好后,再对临时表进行过滤的条件。这时已经没有left join的含义(必须返回左边表的记录)了,条件不为真的就全部过滤掉。

    在使用INNER JOIN时会产生一个结果集,WHERE条件在这个结果集中再根据条件进行过滤,如果把条件都放在ON中,在INNER JOIN的时候就进行过滤了,比如

    SELECT *

    FROM A

    INNER JOIN B

    ON B.ID = A.ID

    AND B.State = 1

    INNER JOIN C

    ON B.ID = C.ID

    在联查B表时,就把状态不等于1的忽略掉了,这样对于状态不等于1的就不需要去联查C表了

    SELECT *

    FROM A

    INNER JOIN B

    ON B.ID = A.ID

    INNER JOIN C

    ON B.ID = C.ID

    WHERE B.State = 1

    则不管B的状态是否满足,都去联查C,最后再将B状态满足的查出来。

    这样一分析,得出的结论就是inner join on 比直接where的查询效率要高。

    inner join on 后面的条件已经把结果过滤了一遍,而where 则是把限制条件放到最后,执行最后一次查询前结果里值变多了,查询起来变慢了,效率自然变低了。

    然而,对于一般的内联接来说,就是没用例如上面的b.state=1这类的多一层限制,它和where的效率是一样的。而且where在写法上简单,因此对单表的查询一般都用where即可。

    展开全文
  • 参考网址:http://shiyanjun.cn/archives/588.html在hive...经过修改后,将where字段放在on条件中进行判断,执行效率提高到半小时之内结束。在on条件中使用条件,可以发现筛选分区后再进行关联操作,splits只有12个...

    参考网址:http://shiyanjun.cn/archives/588.html

    在hive执行sql过程中,一条sql执行了一个多小时,检查sql发现,在left

    join之后,on只使用了关联字段,而其他筛选条件都在where之中使用。经过修改后,将where字段放在on

    条件中进行判断,执行效率提高到半小时之内结束。在on条件中使用条件,可以发现筛选分区后再进行关联操作,splits只有12个

    INFO  : number of splits:12

    ,而where中使用条件,则是关联之后再进行分区筛选,分片数达到了94个splits,而且需要执行94个map,412个reduce,消耗的资源是非常巨大的。

    INFO : number of splits:94​

    原始hql:

    优化后hql:​

    查看执行计划发现,on中使用分区字段过滤,则执行计划中在scan表的时候就已经过滤掉分区了,而如果在where条件中过滤,则不会在scan中过滤,输入数据量巨大!

    ------------------------------------执行过程日志如下:

    INFO  : Query ID =

    hive_20171026031919_9b1b59f2-b867-466a-95a5-06b5be6daafa

    INFO  : Total jobs = 5

    INFO  : Starting task [Stage-12:MAPREDLOCAL] in

    serial mode

    INFO  : Execution completed successfully

    INFO  : MapredLocal task succeeded

    INFO  : Launching Job 1 out of 5

    INFO  : Starting task [Stage-10:MAPRED] in

    serial mode

    INFO  : Number of reduce tasks is set to 0

    since there's no reduce operator

    INFO  : number of splits:12

    INFO  : Submitting tokens for job:

    job_1508725411753_0155

    INFO  : Kind: HDFS_DELEGATION_TOKEN, Service:

    10.1.2.94:8020, Ident: (HDFS_DELEGATION_TOKEN token 999 for

    hive)

    INFO  : The url to track the job:

    http://host:8088/proxy/application_1508725411753_0155/

    INFO  : Starting Job = job_1508725411753_0155,

    Tracking URL =

    http://host:8088/proxy/application_1508725411753_0155/

    INFO  : Kill Command =

    /opt/cloudera/parcels/CDH-5.8.0-1.cdh5.8.0.p0.42/lib/hadoop/bin/hadoop

    job  -kill job_1508725411753_0155

    INFO  : Hadoop job information for Stage-10:

    number of mappers: 12; number of reducers: 0

    .........​

    INFO  : 2017-10-26 03:21:44,169

    Stage-10 map = 100%,  reduce = 0%, Cumulative CPU

    176.25 sec

    INFO  : MapReduce Total cumulative CPU time: 2

    minutes 56 seconds 250 msec

    INFO  : Ended Job = job_1508725411753_0155

    INFO  : Starting task [Stage-9:CONDITIONAL] in

    serial mode

    INFO  : Stage-11 is filtered out by condition

    resolver.

    INFO  : Stage-2 is selected by condition

    resolver.

    INFO  : Launching Job 2 out of 5

    INFO  : Starting task [Stage-2:MAPRED] in

    serial mode

    INFO  : Number of reduce tasks not specified.

    Estimated from input data size: 12

    INFO  : In order to change the average load for

    a reducer (in bytes):

    INFO  :   set

    hive.exec.reducers.bytes.per.reducer=

    INFO  : In order to limit the maximum number of

    reducers:

    INFO  :   set

    hive.exec.reducers.max=

    INFO  : In order to set a constant number of

    reducers:

    INFO  :   set

    mapreduce.job.reduces=

    INFO  : number of splits:4

    INFO  : Submitting tokens for job:

    job_1508725411753_0156

    INFO  : Kind: HDFS_DELEGATION_TOKEN, Service:

    10.1.2.94:8020, Ident: (HDFS_DELEGATION_TOKEN token 1000 for

    hive)

    INFO  : The url to track the job:

    http://host:8088/proxy/application_1508725411753_0156/

    INFO  : Starting Job = job_1508725411753_0156,

    Tracking URL =

    http://host:8088/proxy/application_1508725411753_0156/

    INFO  : Kill Command =

    /opt/cloudera/parcels/CDH-5.8.0-1.cdh5.8.0.p0.42/lib/hadoop/bin/hadoop

    job  -kill job_1508725411753_0156

    INFO  : Hadoop job information for Stage-2:

    number of mappers: 4; number of reducers: 12

    INFO  : 2017-10-26 03:21:56,128 Stage-2 map =

    0%,  reduce = 0%

    .........​

    INFO  : 2017-10-26 03:27:43,452

    Stage-2 map = 100%,  reduce = 100%, Cumulative CPU

    981.83 sec

    INFO  : MapReduce Total cumulative CPU time: 16

    minutes 21 seconds 830 msec

    INFO  : Ended Job = job_1508725411753_0156

    INFO  : Launching Job 3 out of 5

    INFO  : Starting task [Stage-3:MAPRED] in

    serial mode

    INFO  : Number of reduce tasks not specified.

    Estimated from input data size: 1

    INFO  : In order to change the average load for

    a reducer (in bytes):

    INFO  :   set

    hive.exec.reducers.bytes.per.reducer=

    INFO  : In order to limit the maximum number of

    reducers:

    INFO  :   set

    hive.exec.reducers.max=

    INFO  : In order to set a constant number of

    reducers:

    INFO  :   set

    mapreduce.job.reduces=

    INFO  : number of splits:1

    INFO  : Submitting tokens for job:

    job_1508725411753_0158

    INFO  : Kind: HDFS_DELEGATION_TOKEN, Service:

    10.1.2.94:8020, Ident: (HDFS_DELEGATION_TOKEN token 1002 for

    hive)

    INFO  : The url to track the job:

    http://host:8088/proxy/application_1508725411753_0158/

    INFO  : Starting Job = job_1508725411753_0158,

    Tracking URL =

    http://host:8088/proxy/application_1508725411753_0158/

    INFO  : Kill Command =

    /opt/cloudera/parcels/CDH-5.8.0-1.cdh5.8.0.p0.42/lib/hadoop/bin/hadoop

    job  -kill job_1508725411753_0158

    INFO  : Hadoop job information for Stage-3:

    number of mappers: 1; number of reducers: 1

    INFO  : 2017-10-26 03:28:00,533 Stage-3 map =

    0%,  reduce = 0%

    INFO  : 2017-10-26 03:28:13,143 Stage-3 map =

    100%,  reduce = 0%, Cumulative CPU 6.57 sec

    INFO  : 2017-10-26 03:28:28,700 Stage-3 map =

    100%,  reduce = 100%, Cumulative CPU 15.46 sec

    INFO  : MapReduce Total cumulative CPU time: 15

    seconds 460 msec

    INFO  : Ended Job = job_1508725411753_0158

    INFO  : Launching Job 4 out of 5

    INFO  : Starting task [Stage-4:MAPRED] in

    serial mode

    INFO  : Number of reduce tasks determined at

    compile time: 1

    INFO  : In order to change the average load for

    a reducer (in bytes):

    INFO  :   set

    hive.exec.reducers.bytes.per.reducer=

    INFO  : In order to limit the maximum number of

    reducers:

    INFO  :   set

    hive.exec.reducers.max=

    INFO  : In order to set a constant number of

    reducers:

    INFO  :   set

    mapreduce.job.reduces=

    INFO  : number of splits:1

    INFO  : Submitting tokens for job:

    job_1508725411753_0159

    INFO  : Kind: HDFS_DELEGATION_TOKEN, Service:

    10.1.2.94:8020, Ident: (HDFS_DELEGATION_TOKEN token 1004 for

    hive)

    INFO  : The url to track the job:

    http://host:8088/proxy/application_1508725411753_0159/

    INFO  : Starting Job = job_1508725411753_0159,

    Tracking URL =

    http://host:8088/proxy/application_1508725411753_0159/

    INFO  : Kill Command =

    /opt/cloudera/parcels/CDH-5.8.0-1.cdh5.8.0.p0.42/lib/hadoop/bin/hadoop

    job  -kill job_1508725411753_0159

    INFO  : Hadoop job information for Stage-4:

    number of mappers: 1; number of reducers: 1

    INFO  : 2017-10-26 03:28:42,569 Stage-4 map =

    0%,  reduce = 0%

    INFO  : 2017-10-26 03:28:56,012 Stage-4 map =

    100%,  reduce = 0%, Cumulative CPU 7.64 sec

    INFO  : 2017-10-26 03:29:09,498 Stage-4 map =

    100%,  reduce = 100%, Cumulative CPU 13.13 sec

    INFO  : MapReduce Total cumulative CPU time: 13

    seconds 130 msec

    INFO  : Ended Job = job_1508725411753_0159

    INFO  : Starting task [Stage-0:MOVE] in serial

    mode

    INFO  : Loading data to table otl.oel_test from

    hdfs://test94.eformax.com:8020/user/hive/warehouse/otl.db/oel_test/.hive-staging_hive_2017-10-26_03-19-40_941_4069260026444954348-5/-ext-10000

    INFO  : Starting task [Stage-5:STATS] in serial

    mode

    INFO  : Table otl.oel_test stats: [numFiles=1,

    numRows=188992, totalSize=15418476, rawDataSize=15229484]

    INFO  : MapReduce Jobs

    Launched:

    INFO  : Stage-Stage-10: Map:

    12   Cumulative CPU: 176.25

    sec   HDFS Read: 3308304990 HDFS

    Write: 500780832 SUCCESS

    INFO  : Stage-Stage-2: Map: 4

    Reduce: 12   Cumulative CPU:

    981.83 sec   HDFS Read: 802041177

    HDFS Write: 15495161 SUCCESS

    INFO  : Stage-Stage-3: Map: 1

    Reduce: 1   Cumulative CPU: 15.46

    sec   HDFS Read: 15527532 HDFS

    Write: 17183487 SUCCESS

    INFO  : Stage-Stage-4: Map: 1

    Reduce: 1   Cumulative CPU: 13.13

    sec   HDFS Read: 17193170 HDFS

    Write: 15418554 SUCCESS

    INFO  : Total MapReduce CPU Time Spent: 19

    minutes 46 seconds 670 msec

    INFO  : Completed executing

    command(queryId=hive_20171026031919_9b1b59f2-b867-466a-95a5-06b5be6daafa);

    Time taken: 565.401 seconds

    INFO  : OK

    展开全文
  • 写sql的时候很多小伙伴会写 left join where,然后发现 主表有的,附表没有的没有返回 主要区别 left-join中,即使有相同的查询条件,结果也不...inner-join的时候,不管对左表还是右表进行筛选,on-join和on-where
  • 多表join时条件写在where和on的区别(总结篇) 在开发过程中经常遇到这种情况: 多表关联join时,到底限制的条件是写在where后面效率高还是写在on后面,又或者是先对表过滤使表的数据量减少,到底这三种效率哪种更高...
  • 我们通常的认知是联表查询时ON是作用于联表前(时)的过滤条件,WHERE是对联表后的数据的过滤条件,但hive sql查询有个特殊点需要关注,那就是对于left join中的左表ON过滤条件有可能会被忽略,比如 SELECT DISTINCT...
  • Is there any difference performance wise when we run join queries using "JOIN ON" and "WHERE" clause? (regardless of the number of tables or the number of entries in the tables)Not sure whether this t...
  • 这里按 MySQL 数据库来说明,这两个查询语言,第一种是左连接的方式,第二种是左...第二种会把派生表外层查询合并,重新调整 SQL 语句,比如这里的第二种查询方式,就有可能直接被重新调整为第一种,如果是这种...
  • sql的join和where区别

    2021-01-19 06:53:38
    join后面可以接on条件和where条件,在这里我主要就是说这两者之间的差别建立两张简单的用来测试的表并添加数据,如下所示,一张表名为id_name,另一张表名为id_age首先看看不添加条件——t2.age ='22'时的结果...
  • 如果直接把b表过滤条件放在where后面,执行顺序是:先对a表数据过滤,然后b表全部数据关联之后,在reduce 阶段才会对b表过滤条件进行过滤数据,此时如果b表数据量很大的话,效率就会很低。因此对于应该在map 阶段...
  • 首先,贴一个待优化的sql语句select * from A left join B on A.c = B.c where A.employee_id = 3需求解读:A表left join B表,并且指定A表中的employee_id为一个具体的值在c字段不是任何索引,A B 表各有1W多条数据...
  • 2)使用on进行join连接的数据筛选3)where子句基于指定的条件对记录行进行筛选;4)group by子句将数据划分为多个分组;5)cube, rollup6)使用聚集函数进行计算;7)使用having子句筛选分组;8)计算所有的表达式;9)计算...
  • 有这样的一个问题mysql查询使用mysql中left(right)join筛选条件在onwhere查询出的数据是否有差异。可能只看着两个关键字看不出任何的问题。那我们使用实际的例子来说到底有没有差异。例如存在两张表结构表结构1...
  • sql的join和where有什么区别发布时间:2020-09-17 10:17:15来源:亿速云阅读:87作者:小新小编给大家分享一下sql的join和where有什么区别,相信大部分人都还不怎么了解,因此分享这篇文章给大家参考一下,希望大家...
  • left join-on-where 的区别

    2021-08-06 10:40:23
    1. 摘要 关于这两种写法的重要知识点摘要如下: left-join 时,即使有相同的查询条件,二者的查询结果集也不同,原因是优先级... inner-join 时,不管是对左表还是右表进行筛选,on-and on-where 都会对生成的临时
  • 一.Join语法概述join 用于多表中字段之间的联系,语法如下:... FROM table1 INNER|LEFT|RIGHT JOIN table2 ON ...下面是ecshop 的商品表品牌表的查询,请问它们的查询效率有什么区别呢?还有一个问题是 left j...
  • sql语句2:select a.*, b.* from a left join b on a.id = b.id where a.type = 1; sql语句3:select a.*, b.* from a left join b on a.id = b.id and b.class = 1; sql语句1的执行结果为: a.id a.type b.id b...
  • 还有一个问题是 left join 和join效率哪个高一点呢。谢谢 !!SELECT a.`goods_id` , a.`goods_name` , b.brand_nameFROM `ecs_goods` AS aLEFT JOIN ecs_brand AS b ON a.`brand_id` = b.`brand...
  • 「MySQL笔记」left join-on-and 与 left join-on-where 的区别2021-3-83001. 摘要关于这两种写法的重要知识点摘要如下:left-join 时,即使有相同的查询条件,二者的查询结果集也不同,原因是优先级导致的,on 的...
  • join on后面也能进行条件筛选,where后面也能加条件进行筛选,但两者的结果是不一样的。下面通过实际数据案例来说明问题。 数据准备: 建表与写入数据 A 表 hive >create table tempTableAzw(id int,name ...
  • 今天在使用left join进行连接查询的时候,由于过滤条件写错了导致查询的结果与自己预期想要达到的结果不一致,在这里通过一个简单的demo记录一下。 二、demo 现在有两张表,一张班级表,一张学生表。如下图所示: ...
  • user表:id | name---------1 | libk2 | zyfon3 | daodaouser_action表:user_id | action---------------1 | jump1 | kick1 | jump2 | run4 | swimsql:select id, name, action from user as uleft join user_action ...
  • 另外方式二有二种 不推荐的写法查询时间较久,如下 --方式二先 left join onwhere条件 用时 5.641s 5.488s 7.679s 6.230 select a.* from af_archive a left join archiveedituser b on a.ArchiveUUID=b....
  • sql中join时,whereon的区别前言一、SQL之Left join、right join和inner join的区别二、举例说明1.准备两张表2.inner join总结 前言 最近在学sql的join方法时候,用到了on的关键字,因此看了一下和where的区别,...
  • FROM table1 INNER|LEFT|RIGHT JOIN table2 ON conditionatable1:左表;table2:右表。JOIN 按照功能大致分为如下三类:INNER JOIN(内连接,或等值连接):取得两个表中存在连接匹配关系的记录。LEFT JOIN(左连接):...
  • (其他JOIN参数也是显性连接)WHERE INNER JOIN产生的连接关系,没有本质区别,结果也一样。但是!隐性连接随着数据库语言的规范发展,已经逐渐被淘汰,比较新的数据库语言基本上已经抛弃了隐性连接,全部采用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 74,401
精华内容 29,760
关键字:

on的效率where和join