Ⅰ sql的执行顺序 与 游标
最近项目中使用了很多大sql，在编码时sql经常出现执行错误，记录下sql的执行顺序，在编码时就考虑全面，省的之后还要继续花时间进行试验调试。
(8)SELECT (9)DISTINCT (11)<Top Num> <select list>
(1)FROM [left_table]
(3)<join_type> JOIN <right_table>
(2)ON <join_condition>
(4)WHERE <where_condition>
(5)GROUP BY <group_by_list>
(6)WITH <CUBE | RollUP>
(7)HAVING <having_condition>
(10)ORDER BY <order_by_list>
1.FROM： 对FROM子句中的前两个表执行笛卡尔积（Cartesian proct)(交叉联接），生成虚拟表VT1
2.ON： 对VT1应用ON筛选器。只有那些使为真的行才被插入VT2。
3.OUTER(JOIN)： 如 果指定了OUTER JOIN（相对于CROSS JOIN 或(INNER JOIN),保留表（preserved table：左外部联接把左表标记为保留表，右外部联接把右表标记为保留表，完全外部联接把两个表都标记为保留表）中未找到匹配的行将作为外部行添加到 VT2,生成VT3.如果FROM子句包含两个以上的表，则对上一个联接生成的结果表和下一个表重复执行步骤1到步骤3，直到处理完所有的表为止。
4.WHERE： 对VT3应用WHERE筛选器。只有使为true的行才被插入VT4.
5.GROUP BY： 按GROUP BY子句中的列列表对VT4中的行分组，生成VT5.
6.CUBE|ROLLUP： 把超组(Suppergroups)插入VT5,生成VT6.
7.HAVING： 对VT6应用HAVING筛选器。只有使为true的组才会被插入VT7.
8.SELECT： 处理SELECT列表，产生VT8.
9.DISTINCT： 将重复的行从VT8中移除，产生VT9.
10.ORDER BY： 将VT9中的行按ORDER BY 子句中的列列表排序，生成游标（VC10).
11.TOP： 从VC10的开始处选择指定数量或比例的行，生成表VT11,并返回调用者。
注：步骤10，按ORDER BY子句中的列列表排序上步返回的行，返回游标VC10.这一步是第一步也是唯一一步可以使用SELECT列表中的列别名的步骤。这一步不同于其它步骤的 是，它不返回有效的表，而是返回一个游标。SQL是基于集合理论的。集合不会预先对它的行排序，它只是成员的逻辑集合，成员的顺序无关紧要。对表进行排序 的查询可以返回一个对象，包含按特定物理顺序组织的行。ANSI把这种对象称为游标。理解这一步是正确理解SQL的基础。
因为这一步不返回表（而是返回游标），使用了ORDER BY子句的查询不能用作表表达式。表表达式包括：视图、内联表值函数、子查询、派生表和共用表达式。它的结果必须返回给期望得到物理记录的客户端应用程序。例如，下面的派生表查询无效，并产生一个错误：select * from(select orderid,customerid from orders order by orderid) as d
在SQL中，表表达式中不允许使用带有ORDER BY子句的查询，而在T—SQL中却有一个例外（应用TOP选项）。所以要记住，不要为表中的行假设任何特定的顺序。换句话说，除非你确定要有序行，否则不要指定ORDER BY 子句。排序是需要成本的，SQL Server需要执行有序索引扫描或使用排序运行符。
参考：
https://www.cnblogs.com/knowledgesea/p/3699851.html
https://www.cnblogs.com/
Ⅱ 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后面,所以就有了这么个顺序.如果不遵循顺序，就会出现错误。
Ⅲ 数据库中，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(*)也是分组函数。
Ⅳ sql left join 的执行顺序
SQL语句执行的时候是有一定顺序的。理解这个顺序对SQL的使用和学习有很大的帮助。
1.from 先选择一个表，或者说源头，构成一个结果集。
2.where 然后用where对结果集进行筛选。筛选出需要的信息形成新的结果集.
3.group by 对新的结果集分组.
4.having 筛选出想要的分组.
5.select 选择列
6.order by 当所有的条件都弄完了。最后排序
我的理解是这样，SQL语句中无论是否连接的其他表。 无论如何都要先形成一个结果集。后面的顺序不变！
只不过使用连接时，形成结果集合的方式略有不同。这个和 Left Join的实现原理有关。
select a.name,b.name
from T_left a //1
Left Join T_Right b //3
ON a.id = b.id //2
使用Left Join 形成结果集的方式是这样的。
. 首先对From子句中的前两个表，执行笛卡尔积运算。运算结果 形成一个结果集合。
. ON按条件，对上边的结果集，进行筛选，形成新的结果集。
. 以左连接为例，如果T_left中存在未匹配到的行。那么把T_left中的这几行以外部行的形式加到上边的结果集中形成新的结果集。
如果存在多张表，重复1~3过程！
select * from A left join B on A.aid = B.bid right join C on A.aid =C.cid;
// 最终返回的是 C 表中的数据，
1.A left join B 返回A表数据，附带B表中符合条件的数据
2.A left join B 假设等于结果 AB
3.AB right join C 返回C，附带AB中符合条件的数据
Ⅳ sql语句执行顺序
1、先执行from,join来确定表之间的连接关系，得到初步的数据。
2、where对数据进行普通的初步的筛选。
3、group by 分组。
4、各组分别执行having中的普通筛选或者聚合函数筛选。
5、然后把再根据我们要的数据进行select，可以是普通字段查询也可以是获取聚合函数的查询结果，如果是集合函数，select的查询结果会新增一条字段。
6、将查询结果去重distinct。
7、最后合并各组的查询结果，按照order by的条件进行排序。
SQL语句性能优化：
1， 对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。
2，应尽量避免在 where 子句中对字段进行 null 值判断，创建表时NULL是默认值，但大多数时候应该使用NOT NULL，或者使用一个特殊的值，如0，-1作为默 认值。
3，应尽量避免在 where 子句中使用!=或<>操作符， MySQL只有对以下操作符才使用索引：<，<=，=，>，>=，BETWEEN，IN，以及某些时候的LIKE。
4，应尽量避免在 where 子句中使用 or 来连接条件， 否则将导致引擎放弃使用索引而进行全表扫描， 可以 使用UNION合并查询：select id from t where num=10 union all select id from t where num=20
Ⅵ sas中sql中的优先级
sql执行顺序优先级由高到低依次是：from关键字后面的语句、where关键字后面的语句、“group by”后面的语句、select后面的语句、“order by”后面的语句。
php入门到就业线上直播课：进入学习
这一条语句包含我们经常用到的一些关键字，select，from，where，group by，order by，它的执行顺序如下：
先执行from关键字后面的语句，明确数据的来源，它是从哪张表取来的。
接着执行where关键字后面的语句，对数据进行筛选。
再接着执行group by后面的语句，对数据进行分组分类。
然后执行select后面的语句，也就是对处理好的数据，具体要取哪一部分。
最后执行order by后面的语句，对最终的结果进行排序。
Ⅶ Hive SQL语句执行顺序
Hive 中 sql 语句的执行顺序如下：
from .. where .. join .. on .. select .. group by .. select .. having .. distinct .. order by .. limit .. union/union all
下面我们通过一个 sql 语句分析下：
上面这条 sql 语句是可以成功执行的，我们看下它在 MR 中的执行顺序：
Map 阶段 ：
Rece 阶段 ：
上面这个执行顺序到底对不对呢，我们可以通过 explain 执行计划来看下，内容过多，我们分阶段来看。
我们看到 Stage-5 是根，也就是最先执行 Stage-5，Stage-2 依赖 Stage-5，Stage-0 依赖 Stage-2。
图中标 ① 处是表扫描操作，注意先扫描的 b 表，也就是 left join 后面的表，然后进行过滤操作（图中标 ② 处），我们 sql 语句中是对 a 表进行的过滤，但是 Hive 也会自动对 b 表进行相同的过滤操作，这样可以减少关联的数据量。
先扫描 a 表（图中标 ① 处）；接下来进行过滤操作 idno > �'（图中标 ② 处）；然后进行 left join，关联的 key 是 idno（图中标 ③ 处）；执行完关联操作之后会进行输出操作，输出的是三个字段，包括 select 的两个字段加 group by 的一个字段（图中标 ④ 处）；然后进行 group by 操作，分组方式是 hash（图中标 ⑤ 处）；然后进行排序操作，按照 idno 进行正向排序（图中标 ⑥ 处）。
首先进行 group by 操作，注意此时的分组方式是 mergepartial 合并分组（图中标 ① 处）；然后进行 select 操作，此时输出的字段只有两个了，输出的行数是 30304 行（图中标 ② 处）；接下来执行 having 的过滤操作，过滤出 count_user>1 的字段，输出的行数是 10101 行（图中标 ③ 处）；然后进行 limit 限制输出的行数（图中标 ④ 处）；图中标 ⑤ 处表示是否对文件压缩，false 不压缩。
限制最终输出的行数为 10 行。
通过上面对 SQL 执行计划的分析，总结以下几点：
Ⅷ SQL SELECT语句总结（一）
SELECT查询基本语法：
5. SELECT COLUMN_LIST
1. FROM TABLE_NAME
2. WHERE
3. GROUP BY
4. HAVING
6. ORDER BY
7. OFFSET
8. FETCH
SELECT语句的执行顺序如上，上一步返回一个结果集，下一步操作该结果集，然后返回新的结果集给再下一步，注意1是FROM，5是SELECT，6是ORDER BY。
这样就很好了解GROUP BY 和HAVING之间的关系了，先GROUP BY分组得出一个结果集，但是该结果集中的数据并不是我们都想要的，HAVING语句就是用来筛选这个结果集，来获得我们想要的结果。
SELECT DEPTNO, COUNT(*)
FROM EMP
GROUP BY DEPTNO
HAVING COUNT(*) > 2
AND AVG(SAL) <4000;
1. 既然已经根据DEPTNO分组了，那在SELECT后，就应该有分组字段DEPTNO。
2. 如果只根据DEPTNO分组，那分组后的结果集，每行就是一个唯一的DEPTNO。
3. 在HAVING中，无论是COUNT(*)还是AVG(SAL)都是组的属性，COUNT(*)是每组中数据的行数，AVG(SAL)是每组的平均工资。
Ⅸ sql执行顺序
我们先执行from,join来确定表之间的连接关系，得到初步的数据where对数据进行普通的初步的筛选group by 分组各组。
电脑：华为MateBook14
系统：Windows10
软件：本地设置1.0MySql数据库
1、from
先确定从哪个表中取数据，所以最先执行from tab。存在多表连接，from tab1，tab2。可以对表加别名，方便后面的引用。
Ⅹ SQL执行顺序
查询语句中select from where group by having order by的执行顺序
1.查询中用到的关键词主要包含六个，并且他们的顺序依次为
select--from--where--group by--having--order by
其中select和from是必须的，其他关键词是可选的，这六个关键词的执行顺序
与sql语句的书写顺序并不是一样的，而是按照下面的顺序来执行
from--where--group by--having--select--order by,
from:需要从哪个数据表检索数据
where:过滤表中数据的条件
group by:如何将上面过滤出的数据分组
having:对上面已经分组的数据进行过滤的条件
select:查看结果集中的哪个列，或列的计算结果
order by :按照什么样的顺序来查看返回的数据
2.from后面的表关联，是自右向左解析的
而where条件的解析顺序是自下而上的。
也就是说，在写SQL文的时候，尽量把数据量大的表放在最右边来进行关联，
而把能筛选出大量数据的条件放在where语句的最下面。
SQL Select语句完整的 执行顺序 【从DBMS使用者角度】：
1、from子句组装来自不同数据源的数据；
2、where子句基于指定的条件对记录行进行筛选；
3、group by子句将数据划分为多个分组；
4、使用聚集函数进行计算；
5、使用having子句筛选分组；
6、计算所有的表达式；
7、使用order by对结果集进行排序 。
from 子句--执行顺序为从后往前、从右到左
表名(最后面的那个表名为驱动表，执行顺序为从后往前, 所以数据量较少的表尽量放后）
oracle 的解析器按照从右到左的顺序处理，FROM 子句中的表名，FROM 子句中写在最后的表(基础表 driving
table)将被最先处理，即最后的表为驱动表，在FROM 子句中包含多个表的情况下,你必须选择记录条数最少的表作为基础表。如果有3
个以上的表连接查询, 那就需要选择交叉表(intersection table)作为基础表, 交叉表是指被其他表所引用的表
多表连接时，使用表的别名并把别名前缀于每个Column上。可以减少解析的时间并减少那些由Column 歧义引起的语法错误.
where子句--执行顺序为自下而上、从右到左
ORACLE 采用自下而上从右到左的顺序解析Where 子句,根据这个原理,表之间的连接必须写在其他Where 条件之前, 可以过滤掉最大数量记录的条件必须写在Where 子句的末尾。
group by--执行顺序从左往右分组
提高GROUP BY 语句的效率, 可以通过将不需要的记录在GROUP BY 之前过滤掉。即在GROUP BY前使用WHERE来过虑，而尽量避免GROUP BY后再HAVING过滤。
having 子句----很耗资源，尽量少用
避免使用HAVING 子句, HAVING 只会在检索出所有记录之后才对结果集进行过滤. 这个处理需要排序,总计等操作.
如果能通过Where 子句在GROUP BY前限制记录的数目,那就能减少这方面的开销.
(非oracle 中)on、where、having 这三个都可以加条件的子句中，on 是最先执行，where 次之，having 最后，因为on 是先把不符合条件的记录过滤后才进行统计，它就可以减少中间运算要处理的数据，按理说应该速度是最快的，
where 也应该比having 快点的，因为它过滤数据后才进行sum，在两个表联接时才用on 的，所以在一个表的时候，就剩下where 跟having比较了。
在这单表查询统计的情况下，如果要过滤的条件没有涉及到要计算字段，那它们的结果是一样的，只是where 可以使用rushmore 技术，而having 就不能，在速度上后者要慢。
如果要涉及到计算的字段，就表示在没计算之前，这个字段的值是不确定的，where 的作用时间是在计算之前就完成的，而having 就是在计算后才起作用的，所以在这种情况下，两者的结果会不同。
在多表联接查询时，on 比where 更早起作用。系统首先根据各个表之间的联接条件，把多个表合成一个临时表后，再由where 进行过滤，然后再计算，计算完后再由having 进行过滤。
由此可见，要想过滤条件起到正确的作用，首先要明白这个条件应该在什么时候起作用，然后再决定放在那里。
select子句--少用*号，尽量取字段名称 。
ORACLE 在解析的过程中, 会将依次转换成所有的列名, 这个工作是通过查询数据字典完成的, 使用列名意味着将减少消耗时间。
sql 语句用大写的；因为 oracle 总是先解析 sql 语句，把小写的字母转换成大写的再执行
order by子句--执行顺序为从左到右排序,很耗资源