⑴ sql的where子句查询条件的执行顺序
过滤掉最多数据最多的先执行，这些都是优化器做的事
⑵ sql执行顺序以及on和where的区别
（1.)select语句的执行顺序
Processing Order of the SELECT statement
The following steps show the processing order for a SELECT statement.
1.FROM
2.ON
3.JOIN
4.WHERE
5.GROUP BY
6.WITH CUBE or WITH ROLLUP
7.HAVING
8.SELECT
9.DISTINCT
10.ORDER BY
11.TOP
(5)SELECT DISTINCT
（7）TOP(<top_specification>) <select_list>
(1)FROM <left_table> <join_type> JOIN <right_table> ON <on_predicate>
(2)WHERE <where_predicate>
(3)GROUP BY <group_by_specification>
(4)HAVING <having_predicate>
(6)ORDER BY <order_by_list>
T-SQL在查询各个阶级分别干了什么：
（1）FROM 阶段
FROM阶段标识出查询的来源表，并处理表运算符。在涉及到联接运算的查询中（各种join），主要有以下几个步骤：
a.求笛卡尔积。不论是什么类型的联接运算，首先都是执行交叉连接（cross join），求笛卡儿积，生成虚拟表VT1-J1。
b.ON筛选器。这个阶段对上个步骤生成的VT1-J1进行筛选，根据ON子句中出现的谓词进行筛选，让谓词取值为true的行通过了考验，插入到VT1-J2。
c.添加外部行。如果指定了outer join，还需要将VT1-J2中没有找到匹配的行，作为外部行添加到VT1-J2中，生成VT1-J3。
经过以上步骤，FROM阶段就完成了。概括地讲，FROM阶段就是进行预处理的，根据提供的运算符对语句中提到的各个表进行处理（除了join，还有apply，pivot，unpivot）
（2）WHERE阶段
WHERE阶段是根据<where_predicate>中条件对VT1中的行进行筛选，让条件成立的行才会插入到VT2中。
（3）GROUP BY阶段
GROUP阶段按照指定的列名列表，将VT2中的行进行分组，生成VT3。最后每个分组只有一行。
（4）HAVING阶段
该阶段根据HAVING子句中出现的谓词对VT3的分组进行筛选，并将符合条件的组插入到VT4中。
（5）SELECT阶段
这个阶段是投影的过程，处理SELECT子句提到的元素，产生VT5。这个步骤一般按下列顺序进行
a.计算SELECT列表中的表达式，生成VT5-1。
b.若有DISTINCT，则删除VT5-1中的重复行，生成VT5-2
c.若有TOP，则根据ORDER BY子句定义的逻辑顺序，从VT5-2中选择签名指定数量或者百分比的行，生成VT5-3
（6）ORDER BY阶段
根据ORDER BY子句中指定的列明列表，对VT5-3中的行，进行排序，生成游标VC6.
如果On和where只能选其一的话：
先进行on的过滤, 而后才进行join, 这样就避免了两个大表产生全部数据的笛卡尔积的庞大数据.
这些步骤执行时, 每个步骤都会产生一个虚拟表，该虚拟表被用作下一个步骤的输入。这些虚拟表对调用者（客户端应用程序或者外部查询）不可用。只是最后一步生成的表才会返回 给调用者。
如果没有在查询中指定某一子句，将跳过相应的步骤。
（2） 那 on 和where 那个更高效呢
如果是inner join, 放on和放where产生的结果一样, 但没说哪个效率速度更高? 如果有outer join (left or right), 就有区别了, 因为on生效在先, 已经提前过滤了一部分数据, 而where生效在后.
综合一下, 感觉还是放在on里更有效率, 因为它先于where执行.
先笛卡尔积, 然后再on过滤, 如果join是inner的, 就继续往下走, 如果join 是left join, 就把on过滤掉的左主表中的数据再添加回来; 然后再执行where里的过滤;
on中不是最终过滤, 因为后面left join还可能添加回来, 而where才是最终过滤.
只有当使用外连接(left, right)时, on 和 where 才有这个区别, 如果用inner join, 在哪里制定都一样, 因为on 之后就是where, 中间没有其它步骤.
⑶ sql语句的执行顺序是什么，为什么下面这两个sql执行的结果是一样的
你这两个sql语句只是运行顺序不同
第一个sql语句你嵌套多一层子查询，先把sum(case when right(jym,1) in(2,8) then jyje else 0 end)/100 两个聚合函数算出来，然后在分组having直接过滤。
而第二个sql是在having的时候才去算sum(case when right(jym,1) in(2,8) then jyje else 0 end)/100 两个聚合函数的值。
但是你最后都是用这个条件去过滤的，所以结果是一样的
⑷ sql查询语句的各个命令执行的标准顺序是什么为什么
查询语句是sql语句中使用最多的操作，也涉及到非常多的命令。比如where过滤，groupby分组，order
by
排序
limit取值
having等。虽然多，但是各个命令执行的时候却是有顺序的，顺序如下：select
*from
表名①--
where
条件1②--
group
by
依据列③--
having
条件2④--
order
by
依据列⑤--
limit
0,1为什么是这么个顺序,原因:limit取值永远是最后一个.如果你要order
by排序,前提是要首先得到一个查询结果.查询结果中的三个关键词,where总是是放在表名的后面,而havin过滤永远是放在group后面,所以就有了这么个顺序.如果不遵循顺序，就会出现错误。
⑸ 如何指定where中的执行顺序
由于SQL优化起来比较复杂,并且还会受环境限制,在开发过程中,写SQL必须必须要遵循以下几点的原则：
1.ORACLE采用自下而上的顺序解析WHERE子句,根据这个原理,表之间的连接必须写在其他WHERE条件之前, 那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾. 例如: (低效) SELECT … FROM EMP E WHERE SAL > 50000 AND JOB = ‘MANAGER’ AND 25 < (SELECT COUNT(*) FROM EMP WHERE MGR=E.EMPNO); (高效) SELECT … FROM EMP E WHERE 25 < (SELECT COUNT(*) FROM EMP WHERE MGR=E.EMPNO) AND SAL > 50000 AND JOB = ‘MANAGER’; 2.SELECT子句中避免使用’*’ 当在SELECT子句中列出所有的COLUMN时,使用动态SQL列引用 ‘*’ 是一个方便的方法.可是,这是一个非常低效的方法. 实际上,ORACLE在解析的过程中, 会将’*’ 依次转换成所有的列名, 这个工作是通过查询数据字典完成的, 这意味着将耗费更多的时间. 3.使用表的别名(Alias) 当在SQL语句中连接多个表时, 请使用表的别名并把别名前缀于每个Column上.这样一来,就可以减少解析的时间并减少那些由Column歧义引起的语法错误. 注：Column歧义指的是由于SQL中不同的表具有相同的Column名,当SQL语句中出现这个Column时,SQL解析器无法判断这个Column的归属。
⑹ 数据库中，select where group by having 执行顺序
Group
By
和
Having,
Where
,Order
by这些关键字是按照如下顺序进行执行的：Where,
Group
By,
Having,
Order
by。
一、使用count（列名）当某列出现null值的时候，count（*）仍然会计算，但是count(列名)不会。
二、数据分组(group
by
):
select
列a,聚合函数（聚合函数规范）
from
表明
where
过滤条件
group
by
列a
group
by
字句也和where条件语句结合在一起使用。当结合在一起时，where在前，group
by
在后。即先对select
xx
from
xx的记录集合用where进行筛选，然后再使用group
by
对筛选后的结果进行分组。
三、使用having字句对分组后的结果进行筛选，语法和where差不多:having
条件表达式
需要注意having和where的用法区别：
1.having只能用在group
by之后，对分组后的结果进行筛选(即使用having的前提条件是分组)。
2.where肯定在group
by
之前，即也在having之前。
3.where后的条件表达式里不允许使用聚合函数，而having可以。
四、当一个查询语句同时出现了where,group
by,having,order
by的时候，执行顺序和编写顺序是：
1.执行where
xx对全表数据做筛选，返回第1个结果集。
2.针对第1个结果集使用group
by分组，返回第2个结果集。
3.针对第2个结果集中的每1组数据执行select
xx，有几组就执行几次，返回第3个结果集。
4.针对第3个结集执行having
xx进行筛选，返回第4个结果集。
5.针对第4个结果集排序。
拓展资料
当我们看到一个类似上述的包含了where,
group
by,
having，
order
by等关键字的SQL时，我们要首先要知道其执行顺序是怎样的，才能判断出其所表达的含义；
下面列出其执行顺序：
1.
根据where子句选择行；
2.
根据group
by
子句组合行；
3.
根据having子句筛选组；
4.
根据order
by子句中的分组函数的结果对组进行排序，order
by必须使用分组函数或者使用Group
by子句中指定的列；
下面看一个例子：
我们现在知道，其执行顺序如下：
1.基于Where
Rating>1
筛选出符合条件的行；
2.基于group
by
CategoryName
对筛选的结果进行分组；
3.为每个CategoryName组计算Count(*)
4.
基于having
CategoryName
like
'A%'留下符合条件的组
5.
根据order
by
的条件对剩下的行组进行排序，SQL中的count(*)也是分组函数。
⑺ GROUP BY，WHERE，HAVING之间的区别和用法
group by、having、where均为SQL语句中的函数。
一、区别
1、执行顺序不同
在SQL语句中，where语句的执行顺序先于group by，group by语句的执行顺序先于having。
2、执行条件不同
在group by的SQL语句中，select中返回的字段，必须包含在group by语句的后面，作为分组的依据，而且字段包含在聚合函数中。
在having 的SQL语句中，having只能用于group by，having 子句中的每一个元素也必须出现在select列表中，having语句可以使用聚合函数。
where不使用聚合函数。
二、用法
1、where用于筛选查询，通常用在select 的后面。
select city, count(*),age from dbo.user where departmentID=2；
2、group by用于对where的查询结果进行分组，通常放在where之后。
select city, count(*),age from dbo.user where departmentID=2 group by city,age；
3、having一般放在group by之后，对where和group by查询出来的分组进行过滤。
select city, count(*),age from dbo.user where departmentID=2 group by city,age having age >40；
(7)sql语句where执行顺序扩展阅读
ORDER BY子句中还经常会用到排序函数：ASC，DESC
其中，ASC表示升序，DESC为降序
排序函数一般放置在子句的末尾处，表示排序的方式。
例如：SELECT 课程编号，成绩 FROM Score WHERE 学号=‘2006091**1' ORDER BY 成绩 ASC；
⑻ sql 语句中同时使用 top 、 where、 order by， 它们的执行顺序是怎样的
WHERE最先，根据WHERE条件先找出所有数据，WHERE内部的顺序是从后往前，右往左。
然后是ORDER BY顺序整理，如果是ORACLE使用ROWNUM控制就不是了。
最后是TOP N截出前N行。
⑼ SQL where 条件顺序对性能的影响有哪些
SQL Select语句完整的执行顺序：
1、from子句组装来自不同数据源的数据；
2、where子句基于指定的条件对记录行进行筛选；
1）where条件的执行顺序是从右到左的；
2）where条件优先执行索引类条件；
3、group by子句将数据划分为多个分组；
4、使用聚集函数进行计算；
5、使用having子句筛选分组；
6、计算所有的表达式；
7、使用order by对结果集进行排序