精华内容
下载资源
问答
  • with和by的用法区别
    千次阅读
    2021-05-03 07:19:48

    oracle with 语句的用法

    在oracle中,select 查询语句,可以使用with,就是一个子查询,oracle 会把子查询的结果放到临时表中,可以反复使用

    例子:注意,这是sql语句,不是pl/sql语句, 可以直接放到jdbc执行的

    -------------------------------------------

    with

    --入库信息,利用子查询,将数据预处理一次,这样数据就很少了, 下面可以很快的反复查rkxx,

    rkxx as (select sz,zt,sum(se) se --税种,状态,税额

    from zsxx

    where rkrq between '2007-02' and '2007-06' --条件,统计日期

    group by sz,zt

    )

    select sk.sz,sk.se,fk.se,znj.se

    from (select sz,sum(se) se from rkxx --这里可以直接查询with子查询的结果rkxx

    where zt='01'

    group by sz) sk,--税款

    (select sz,sum(se) se from rkxx

    where zt='02'

    group by sz) fk,--罚款

    (select sz,sum(se) se from rkxx

    where zt='03

    group by sz) znj --滞纳金

    where sk.sz=fk.sz

    and sk.sz=znj.sz

    -----------------------------------------------

    这样,经过with预先处理好数据,然后再在处理好的数据上做查询分析,不用再访问原始表, 这样效率是很高的

    注意,预先处理好的数据,一定要少, 可以把条件尽可能的加到with子查询中,这样后面的查询才会更快

    更多相关内容
  • SQL Server中的用法为group by colomn with [rollup|cube],首先要弄明白rollup cube,就要知道group by用法,group by 为对列进行分组,只展现分组统计的值,而 rollup 为分层次展现,cube 为展现列中所有层次...
  • oracle connect by用法以及with递归

    千次阅读 2018-09-23 15:02:45
    在oracle中start with connect by (prior) 用来对树形结构的数据进行查询。其中start with conditon 给出的是数据搜索范围, connect by后面给出了递归查询的条件; 涉及的伪列及函数: – connect_by_isleaf 伪列 – ...

    环境:11g
    准备:
    在oracle中start with connect by (prior) 用来对树形结构的数据进行查询。其中start with conditon 给出的是数据搜索范围, connect by后面给出了递归查询的条件;
    涉及的伪列及函数:
    – connect_by_isleaf 伪列
    – connect_by_root()获取根节点
    – sys_connect_by_path(a,b) 显示分层路径
    – connect_by_iscycle 是否循环

    语法:
    [start with]
    connect by [nocycle] prior 条件
    [and]

    -- 表结构
    drop table   menu;
    create table menu(
     mid varchar2(64) not null,
     parent_id varchar2(64) not null,
     mname varchar2(100) not null,
     mdepth number(2) not null,
     primary key (mid)
    );
    
    -- 初始化数据
    -- 顶级菜单
    insert into menu values ('100000', '0', '顶级菜单1', 1);
    insert into menu values ('200000', '0', '顶级菜单2', 1);
    insert into menu values ('300000', '0', '顶级菜单3', 1); 
    
    -- 父级菜单
    -- 顶级菜单1 直接子菜单
    insert into menu values ('110000', '100000', '菜单11', 2);
    insert into menu values ('120000', '100000', '菜单12', 2);
    insert into menu values ('130000', '100000', '菜单13', 2);
    insert into menu values ('140000', '100000', '菜单14', 2); 
    -- 顶级菜单2 直接子菜单
    insert into menu values ('210000', '200000', '菜单21', 2);
    insert into menu values ('220000', '200000', '菜单22', 2);
    insert into menu values ('230000', '200000', '菜单23', 2); 
    -- 顶级菜单3 直接子菜单
    insert into menu values ('310000', '300000', '菜单31', 2); 
    
    -- 菜单13 直接子菜单
    insert into menu values ('131000', '130000', '菜单131', 3);
    insert into menu values ('132000', '130000', '菜单132', 3);
    insert into menu values ('133000', '130000', '菜单133', 3);
    
    -- 菜单132 直接子菜单
    insert into menu values ('132100', '132000', '菜单1321', 4);
    insert into menu values ('132200', '132000', '菜单1332', 4);
    
    

    测试:

    
    --看prior修饰的对象,如果是父id,则获取的是父节点数据,反之获取的是子节点数据
    --1找指定节点的所有父节点(直接或间接) 
    select *
      from menu aa
     start with aa.mid = '130000'
    connect by aa.mid = prior aa.parent_id;
    --或者
    select *
      from menu aa
     start with aa.mid = '130000'
    connect by  prior aa.parent_id = aa.mid;
    
    
    --如果不用树查询,如何实现呢?
    --需要知道查询的次数,然后不断的union all,比较麻烦
    --或者更改表设计
    select aa.* from menu aa where aa.mid='130000'
    union all
    select b.* from menu b where b.mid=(select aa.parent_id from menu aa where aa.mid='130000');
    
    
    
    
    --2找到指定节点的所有子节点(直接或间接)  
    select *
      from menu aa
     start with aa.mid = '130000'
    connect by prior aa.mid = aa.parent_id;
    
    --或者
    select aa.*, level 层级号
      from menu aa
     start with aa.mid = '130000'
    connect by aa.parent_id = prior aa.mid;
    
    
    
    --3.只获取指定节点的直接父节点
    select * from menu aa 
    where  aa.mid='130000';
    
    
    --4.只获取指定节点的直接字节点,利用level限制
    select *
      from (select aa.*, level lev
              from menu aa
             start with aa.mid = '130000'
            connect by aa.parent_id = prior aa.mid) tt
     where tt.lev = 2; --注意:在外面限制,里面限制没用
    --或者
    select * from menu aa where aa.parent_id='130000';
    
    
    --4.1 获取不是'130000'分支的树
    select aa.*, level 层级号
      from menu aa
    connect by aa.parent_id = prior aa.mid
           and aa.mid != '130000'
           and aa.parent_id;
    
    
    --5.获取指定菜单的子菜单的个数,包括自已
    select count(1) from 
    (
    select * from menu aa 
    start with aa.mid='130000' 
    connect by prior  aa.mid = aa.parent_id
    );
    
    --5.1 获取每一个菜单的子菜单的个数(包括自已,包括直接或间接)
    --思路: 先求出每个菜单的父菜单,再根据父菜单分组,即可得到每个菜单的子菜单个数
    select aa.mid,max(aa.mname),count(1) 子菜单个数 from menu aa 
    group by aa.mid
    connect by aa.mid=prior aa.parent_id
    order by aa.mid;
    
    --如果要不包括自已
    select aa.mid,max(aa.mname),count(1)-1 子菜单个数 from menu aa 
    group by aa.mid
    connect by aa.mid=prior aa.parent_id
    order by aa.mid;
    
    
    
    
    --6 形象展示菜单结构
    --展示 130000的结构
    -- connect_by_isleaf 伪列  
    -- connect_by_root()获取根节点
    -- sys_connect_by_path(a,b) 显示分层路径
    -- siblings by,能保持兄弟关系(层次),优先层次显示,同一层次的再按照字典顺序排序。
    select aa.mid,
           lpad('|-', level * 2, ' ') || aa.mname,
           aa.parent_id,
           decode(connect_by_isleaf, 0, '根节点', 1, '  叶子节点') isleaf,
           connect_by_root(aa.mname) 根节点,
           sys_connect_by_path(aa.mname,'=>') 分层路径 
      from menu aa
    start with aa.mid = '130000'
    connect by aa.parent_id = prior aa.mid
    order siblings by aa.mname;
    
    
    --6.1展示 所有顶级节点的结构
    select * from (
    select aa.mid,
           lpad('|-', level * 2, ' ') || aa.mname 菜单结构,
           aa.parent_id,
           decode(connect_by_isleaf, 0, '根节点', 1, '  叶子节点') isleaf,
           connect_by_root(aa.mname) 根节点,
           connect_by_root(aa.mid) rootid
      from menu aa
      connect by aa.parent_id = prior aa.mid) tt
      where tt.rootid in(select a.mid from menu a where a.parent_id='0') 
      order by tt.rootid,tt.mid;
    
    

    顶级节点

    
    --6.2 如果要去掉某个分支呢? 先把全部的树查询出来,再minus掉指定分支;
    
    --7. 获取指定范围的树形数据
    --比如获取20部门的 顶级节点的子节点,已知 mgr=null在部门10
    select * from emp e
    where e.deptno=20
    start with e.mgr is null
    connect by prior e.empno=e.mgr;
     --发现竟然有数据,说明这个查询肯定是不对的,因为此时的where作用的是整个树形的查询结果,而不是emp
    --所有在查询的一开始就要限制范围
    --正确写法
    select *
      from (select * from emp e where e.deptno = 20) e
     start with e.mgr is null
    connect by prior e.empno = e.mgr;
    
    8.where过滤的问题,where的过滤条件针对的是树查询结果进行过滤的;
    注意:这说的是where的过滤条件(带常量的),不是连接条件!!!
    select *
      from menu aa 
      where aa.mid!='130000'
     start with aa.mid = '130000'
    connect by prior aa.mid = aa.parent_id;
    
    

    在这里插入图片描述在这里插入图片描述

    这个时候有5条记录;相当于把’130000’的直接父节点的记录删除掉了;
    从执行计划可以看到,是在最后把结果求出来后,再过滤的;

    --如果把条件放在connect by后面呢?
    select *
      from menu aa 
     start with aa.mid = '130000'
    connect by prior aa.mid = aa.parent_id
    and   aa.mid!='130000'; 
    
    

    在这里插入图片描述在这里插入图片描述

    发现结果没有变化,为啥呢?
    猜测是在递归循环的过程中,无法过滤start with的mid节点条件;
    导致过滤无效;下面的列子会说明的;

    再看:
    select *
    from menu aa
    start with aa.mid = ‘130000’
    connect by prior aa.mid = aa.parent_id
    and aa.mid!=‘132000’;
    在这里插入图片描述
    这个是在递归循环过程中的过滤条件,在把mid!='132000’时,源头132000没了.那么涉及的parent_id自然没有132000;
    等价于把的mid为132000以及parent_id为132000的全部去掉;
    这种在循环的过程中进行过滤的,过滤效果相对于where过滤条件,过滤的更多;

    select * from emp e
    where e.deptno=20
    start with e.mgr is null
    connect by prior e.empno=e.mgr;
    在这里插入图片描述
    select * from emp e
    start with e.mgr is null
    connect by prior e.empno=e.mgr
    and e.deptno=20;
    在这里插入图片描述
    也可以看到,connect by 后的and条件无法过滤掉start with的开始条件;

    
    --9.cconnect by不要prior呢,可以用来创建数据;
    select * from menu aa 
    start with aa.mid='130000' 
    connect by  aa.mid = aa.parent_id;
    --此时等价于
    select * from menu aa 
    where  aa.mid='130000';
    
    select rownum,level from dual  connect by  rownum<500;
    
    
    
    对于上面的递归查询,在11g之前只能用start with ... connnect by prior来实现,
    从版本11GR2开始,ORACLE支持递归的WITH, 即允许在WITH子查询的定义中对自身引用。
    其他数据库如DB2, Firebird, Microsoft SQL Server, PostgreSQL 都先于ORACLE支持这一特性;
    语法:
    WITH 
    ①  query_name ([c_alias [, c_alias]...])
    ②  AS (subquery)
    ③  [search_clause]
    ④  [cycle_clause]
    ⑤  [,query_name ([c_alias [, c_alias]...]) AS (subquery) [search_clause] [cycle_clause]]... 
    ①这是子查询的名称,和以往不同的是,必须在括号中把这个子查询的所有列名写出来。
    ②AS后面的subquery就是查询语句,递归部分就写在这里。
    ③遍历顺序子句,可以指定深度优先或广度优先遍历顺序。
    ④循环子句,用于中止遍历中出现的死循环。
    ⑤如果还有其他递归子查询,定义同上。
    SELECT empno,
           ename,
           job,
           mgr,
           deptno,
           level,
           SYS_CONNECT_BY_PATH(ename, '\') AS path,
           CONNECT_BY_ROOT(ename) AS top_manager
      FROM EMP
     START WITH mgr IS NULL 
    CONNECT BY PRIOR empno = mgr;
    等价:
    
    WITH T(empno, ename, job, mgr, deptno, the_level, path,top_manager) AS ( ---- 必须把结构写出来
     SELECT empno, ename, job, mgr, deptno ---- 先写锚点查询,用START WITH的条件
      ,1 AS the_level ---- 递归起点,第一层
      ,'\'||ename ---- 路径的第一截
      ,ename AS top_manager ---- 原来的CONNECT_BY_ROOT
     FROM EMP
     WHERE mgr IS NULL ---- 原来的START WITH条件
     UNION ALL ---- 下面是递归部分
     SELECT e.empno, e.ename, e.job, e.mgr, e.deptno ---- 要加入的新一层数据,来自要遍历的emp表
      ,1 + t.the_level  ---- 递归层次,在原来的基础上加1。这相当于CONNECT BY查询中的LEVEL伪列
      ,t.path||'\'||e.ename ---- 把新的一截路径拼上去
      ,t.top_manager  ---- 直接继承原来的数据,因为每个路径的根节点只有一个
     FROM t, emp e   ---- 典型写法,把子查询本身和要遍历的表作一个连接
     WHERE t.empno = e.mgr  ---- 原来的CONNECT BY条件
    ) ---- WITH定义结束
    SELECT * FROM T
    ;
    with循环参考:https://blog.csdn.net/cacasi2568/article/details/55224422
    
    

    好,用法就介绍到这了,不知道内有没收获呀
    下一篇将介绍connect by的优化,这个是个难点;

    end by ysy

    展开全文
  • 请问in,on,of,for,with,by,的用法.pdf
  • 介词in-on.at-for.with-by-of的基本用法.doc
  • Oracle_start_with_connect_by_prior_用法[文].pdf
  • hive group by with cubegrouping sets用法

    千次阅读 2019-09-12 15:43:52
    1.group by with cube 此方式对每一个统计维度打cube,维度的空值自动会变成null,使用coalesce(x x x x,‘all’)把对应维度的null转为all,就是该字段的合计值 select coalesce(page_city_name,'all') as page_...

    group by with cube

    此方式对每一个统计维度打cube,维度的空值自动会变成null,使用coalesce(x x x x,‘all’)把对应维度的null转为all,就是该字段的合计值

    select 
      coalesce(page_city_name,'all') as page_city_name,
      coalesce(item_index,'all') as item_index,
      count(distinct if(partition_event_type='view',device_id,null)) as view_uv,
      count(distinct if(partition_event_type='click',device_id,null)) as click_uv
    from
        (
            select 
                 device_id,                               
                 city_name,   
                 partition_event_type            
             from xxxxxxxxx
             where partition_date='2019-09-10'
             and partition_event_type in ('click','view')
    group by
      page_city_name,
      item_index
    with cube
    

    注意在group by的时候不能写为coalesce(page_city_name,‘all’),否则结果还是会产生null值

    group by
    page_city_name,
    item_index
    group by page_city_name,item_index
    group by
    coalesce(page_city_name,‘all’),
    coalesce(item_index,‘all’)
    group by coalesce(page_city_name,'all'),coalesce(item_index,'all')

    grouping sets

    grouping sets的用法相对简单,实际上就是分别将字段group by之后在union all,示例如下:

    group by 
           module,
           origin,
           page_city_name,
           page_city_rank
    grouping sets(
           (module),
           (module,origin),
           (module,page_city_rank,page_city_name),
           (module,origin,page_city_rank,page_city_name)
        )
    
    
    展开全文
  • Oracle中start with connect by prior用法

    万次阅读 2019-05-09 08:59:57
    最近看到Oracle中有一个很好用的查询,它就是start with connect by prior,说白了就是递归算法。 如果表中存在层次数据,则可以使用层次化查询子句查询出表中行记录之间的层次关系 基本语法: [ START WITH ...

    最近看到Oracle中有一个很好用的查询,它就是start with connect by prior,说白了就是递归算法。 

    如果表中存在层次数据,则可以使用层次化查询子句查询出表中行记录之间的层次关系
    基本语法: 
    [ START WITH CONDITION1 ]
    CONNECT BY [ NOCYCLE ] CONDITION2
    [ NOCYCLE ]参数暂时不解释
    例: 
    select empno, ename, job, mgr, hiredate, sal, comm, deptno, level as lv
    from emp
    start with empno = 7839
    connect by (prior empno) = mgr;

    表中存在层次数据 
    数据之间的层次关系即父子关系,通过表中列与列间的关系来描述,如EMP表中的EMPNO和MGR。EMPNO表示雇员编号,MGR表示领导该雇员的人的编号,在表的每一行中都有一个表示父节点的MGR(除根节点外),通过每个节点的父节点,就可以确定整个树结构。 

    CONNECT BY [ NOCYCLE ] CONDITION2 层次子句作用
    CONDITION2 [PRIOR expr = expr] : 指定层次结构中父节点与子节点之之间的关系。
    CONDITION2 中的 一元运算符 PRIORY 必须放置在连接关系的两列中某一个的前面。在连接关系中,除了可以使用列名外,还允许使用列表达式。

    1.START WITH
    start with 子句为可选项,用来标识哪行作为查找树型结构的第一行(即根节点,可指定多个根节点)。若该子句被省略,则表示所有满足查询条件的行作为根节点。2.关于PRIOR PRIOR置于运算符前后的位置,决定着查询时的检索顺序。 

    2.1 从根节点自顶向下
    --sql 1
    select empno, mgr, level as lv
    from scott.emp a
    start with mgr is null
    connect by (prior empno) = mgr
    order by level;

    --result 1

    --分析
    层次查询执行逻辑:
    a.确定上一行(相对于步骤b中的当前行),若start with 子句存在,则以该语句确定的行为上一行,若不存在则将所有的数据行视为上一行。
    b.从上一行出发,扫描除该行之外所有数据行。
    c.匹配条件 (prior empno) = mgr
    注意 一元运算符 prior,意思是之前的,指上一行
    当前行定义:步骤b中扫描得到的所有行中的某一行
    匹配条件含义:当前行字段 mgr 的值等于上一行字段 empno中的值,若满足则取出该行,并将
    level + 1,
    匹配完所有行记录后,将满足条件的行作为上一行,执行步骤 b,c。直到所有行匹配结束.

    2.1 从根节点自底向上
    --sql 2
    select empno, mgr, level as lv
    from scott.emp a
    start with empno = 7876
    connect by (prior mgr ) = empno
    order by level;

    --result 2

    --分析
    层次查询执行逻辑:
    a.确定上一行(相对于步骤b中的当前行),若start with 子句存在,则以该语句确定的行为上一行,若不存在则将所有的数据行视为上一行。
    b.从上一行出发,扫描除该行之外所有数据行。
    c.匹配条件 (prior mgr ) = empno
    注意 一元运算符 prior,意思是之前的,指上一行
    当前行定义:步骤b中扫描得到的所有行中的某一行
    匹配条件含义:当前行字段 empno 的值等于上一行字段 mgr 中的值,若满足则取出该行,并将
    level + 1,
    匹配完所有行记录后,将满足条件的行作为上一行,执行步骤 b,c。直到所有行匹配结束.
    若不理解上一行当前行看此例子
    select child_id, parent_id, level as lv
    from table_name
    start with child_id = 10
    connect by (prior child_id) = parent_id;

    step1.将下面一行作为上一行

    step2..从上一行出发,扫描除该行之外所有数据行

    step3.匹配条件 (prior child_id) = parent_id,
    取出除上一行之外的数据行如

    比较当前行的 parent_id 与上一行的 child_id,若相等则取出该行作为上一行的子行。
    当上一行的子行全部取出后,将子行再作为上一行,重复步骤1,2
    结果示意图如下

    自顶向下,自下向上口诀:
    start with child_id = 10 connect by (prior child_id) = parent_id
    prior 和 子列在一起,表示寻找它的子孙,即自顶向下,和父列在一起,表示开始寻找她的爸爸,即自下向上。

    展开全文
  • mysql 中 group by with rollup的用法

    千次阅读 2019-09-02 23:53:56
    2.group by 列名 with rollup:不仅可以按照指定的列属性进行分组,还可以完成分组后的聚合操作,以及对所用列的操作。 举一个实例:下面是一个工资表,有三个列属性:部门号,姓名,工资 select * from salary ...
  • 英语中的for,to,at,of,in,on,with用法

    千次阅读 2020-12-20 00:14:25
    英语中的for,to,at,of,in,on,with用法英语中的for,to,at,of,in,on,with用法人气:594 ℃时间:2019-11-07 00:56:02优质解答一、介词按其构成可分为:1.简单介词 at,in,on,to,since,until 等.如:He's worked ...
  • oracle中start with和connect by用法理解

    万次阅读 多人点赞 2017-05-22 16:14:06
    Oracle中start with和connect by 用法理解 转自:http://www.blogjava.net/xzclog/archive/2010/03/05/314642.html,多谢博主分享 connect by 是结构化查询中用到的,其基本语法是: 1 select … from ...
  • oracle with as用法

    万次阅读 2019-10-12 16:00:09
    withas语法 相当于建了个临时表 ,或者sql的别命名 with tmp1 as(select*from aa where id="001"), tmp2as(select*frombb where id="001"), tmp3as(select*from cc where id="001"), ...select *from tmp1 , tmp2,...
  • sql语句中with as 的用法

    千次阅读 2020-12-30 08:43:24
    with tmp as (select * from tb_name) –针对多个别名 with tmp as (select * from tb_name), tmp2 as (select * from tb_name2), tmp3 as (select * from tb_name3), … –相当于建了个e临时表 with e as (select *...
  • mysql 递归函数with recursive的用法

    千次阅读 2022-05-20 10:57:20
    with用法: 简单递归用法: 首先我们引出一个问题: 什么叫做递归? 递归:给定函数初始条件,然后反复调用自身直到终止条件. 例子1:递归得到依次递增的序列: WITH RECURSIVE cte (n) AS ( SELECT 1 UNION ALL SELECT n...
  • sql中,with用法

    千次阅读 2021-01-21 12:07:59
    展开全部1、with表示状态时,还可作“跟上…”“听懂…的话”解,一般用于疑问句或否定句中。2、with表示关系时32313133353236313431303231363533e78988e69d8331333431366334还可作“与…合并〔混合,组合〕”解。3...
  • 1、by:在旁边,从旁边,...(1)附近,如nearby,pass by,go by,sit by the window等; (2)被,如被动语态中的something is done by somebody; (3)截止到……为止,如 Can you finish the job by 9 o'clo...
  • Oracle WITH语句用法

    千次阅读 2020-07-28 14:16:54
    建议使用Oracle with语句创建一个公共临时表。因为子查询在内存临时表中,避免了重复解析,所以执行效率会提高不少。临时表在一次查询结束自动清除。 WITH语句的优点: SQL可读性增强。 with子查询只执行一次,将结果...
  • requestrequire是一组近义、看起来区别不明显的词语,但在起草英文合同或中译英时,这两个词语是否可以...但在中译英时是否有用法上的区别?首先我们就来看一下这两个词语的英文含义:request① to ask formally ...
  • as with区别

    千次阅读 2017-02-21 10:58:06
    as 与with 都可以构成结构来表示伴随状语,as 在此结构中是一个连词,而with 是一个介词,因此构成不同的结构来表示伴随状语: ... As the production increased by 20 percent,we have had another goo
  • with as 临时表的区别

    万次阅读 2020-09-23 15:57:43
    with as 只是把子查询的语句当作了一个表,但是真实的数据并没有插入到数据库,它的好处是增加了代码的可读性进行维护。 --设计累计发生 with ljfssj as ( select b.ProjGUID, COUNT(*) Ljfscs, --...
  • Oracle中的as和with as 的用法

    千次阅读 2019-04-23 14:59:03
    关于Oracle中的as和with as 的用法 在Oracle中as关键字不能用于指定表的别名,在Oracle中指定表的别名时只需在原有表名表的别名之间用空格分隔即可, 但可以用于指定列的别名,但在存储过程中如果列的别名与原有...
  • 数据库中With as union用法

    千次阅读 2020-08-31 19:51:08
    With查询语句不是以select开始的,而是以“WITH”关键字开头 可认为在真正进行查询之前预先构造了一个临时表,之后便可多次使用它做进一步的分析处理 WITH Clause方法的优点 增加了SQL的易读性,如果构造了多个子...
  • SQL- With as 用法

    千次阅读 2018-08-15 19:10:37
    SQL With As用法一.WITH AS的含义用AS语言,也叫做子查询部分(subquery factoring),可以定义一个SQL片断,该SQL片断会被整个SQL语句用到。可以使用SQL语句的可读性更高,也可以在UNION ALL的不同部分,作为提供...
  • reduceByKeygroupByKey区别用法

    万次阅读 2019-06-10 22:37:37
     //groupByKey reduceByKey 的区别:   //他们都是要经过shuffle的,groupByKey在方法shuffle之间不会合并原样进行shuffle,   //reduceByKey进行shuffle之前会先做合并,这样就减少了shuffle的io传送...
  • sql语句中with用法

    千次阅读 2019-10-08 12:00:53
    with嵌套子查询用法 在比较复杂,数据量大的情况下,为了提高查询效率,需要用到一些子查询。一层一层嵌套的子查询不方便,显得sql语句比较繁琐。可以用 with语句 构建临时表查询:具体用法如下: --只有一个临时表...
  • scala中sorted,sortWith,sortBy用法详解

    万次阅读 2017-07-23 23:07:51
    scala的集合中提供了三种排序的方式:sorted,sortWith,sortBy。那么这三种方式有什么不同呢?下面我们结合源码来分析一下1.sorted先来看看scala中sorted的源码。 def sorted[B >: A](implicit ord: Ordering[B]): ...
  • MySQL中with rollup的用法

    千次阅读 2021-04-20 20:06:09
    Mysql中有一个with rollup是用来在分组统计数据的基础上再进行统计汇总,即用来得到group by的汇总信息。 文章目录
  • oracle connect by 用法

    千次阅读 2021-02-03 06:35:28
    Oracle中可以通过START WITH . . . CONNECT BY . . .子句来实现SQL的层次查询,即递归查询 例如: select level||月 月份 from dualconnect by level 13; 或者 select rownum||月 月份 from dualconnect by rownum ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 142,186
精华内容 56,874
热门标签
关键字:

with和by的用法区别