精华内容
下载资源
问答
  • 主要介绍了MySQL数据库高级查询和多表查询,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 实现了数据分页以及高级查询,但是没有实现文本里面的添加商品以及删除功能呢,可用于学习交流
  • 可以参考】 使用封装的思想,极尽...专门的数据库操作工具类(加载注册驱动、获取连接对象、获取语句对象、执行语句、释放资源)、多条件查询公共类(获取条件语句、获取查询请求参数)、web基础servlet+jsp 页面跳转
  • ORACLE高级查询ppt

    2019-12-03 14:23:51
    ORALCE高级查询PPT 主要内容包括 表连接 集合操作符 层次查询 GROUP BY扩展 分析函数
  • MongoDB高级查询用法大全
  • 项目中常用的高级搜索按钮 通过点击按钮下拉一个框 通过框中输入的条件进行查询 框中包含了确定搜索和取消按钮 弹出框有关闭功能 非常实用 qiuqiu770130706
  • 一个非常实用的代码,仿淘宝高级查询,非常实用
  • 很好的sql高级查询练习题 楼主亲测使用 拒绝大忽悠
  • 项目采用Javabean+servlet+jsp开发,运用高级查询和分页技术,对数据库(商品信息【多个表】)数据进行查询,在jsp网页上进行数据展示。展示结果为用户限定的条件从数据库查询的结果。 主要难点:1、mvc框架;2、...
  • asp.net自定义组合高级,实现任意字段组合查询,可以查询为null,区间范围查询,支持模板字段设置。
  • jquery 多条件搜索特效 高级查询 含单选,多选组合查询
  • sql server 高级查询语句小结 讲述sql高级查询语句小结
  • MySql高级查询

    千次阅读 2019-08-18 15:44:12
    DQL高级查询 多表查询(关联查询,连接查询) 1.笛卡儿积 emp表15条记录,dept表4条记录。 连接查询的笛卡尔积为60条记录。 2.内连接 不区分主从表,与连接顺序无关,两张表均满足条件则出现结果集中 ...
    •  DQL高级查询

    •   多表查询(关联查询,连接查询)

             1.笛卡儿积    

                emp表15条记录,dept表4条记录。

                连接查询的笛卡尔积为60条记录。

             2.内连接

                不区分主从表,与连接顺序无关,两张表均满足条件则出现结果集中

    --where子句
    select * from emp,dept
    where emp.deptno = dept.deptno
    --inner join…on…
    select * from emp
    inner join dept
    on emp.deptno = dept.deptno
    --inner join…using…
    select * from emp
    INNER JOIN dept
    using(deptno)

             3.自然连接

                 寻找俩表中字段名称相等,数据类型相同的字段进行连接,会自动去重重复列(如果有多个字段符合要求,那么他们会被作为自然连接的条件)

    --自然连接(等值连接,表的字段名称必须相同,去除重复行)
    select * from emp NATURAL JOIN dept;

            4.外连接

                 有主从表之分,与连接顺序有关。以驱动表为依据,匹配表依次进行查询;匹配表中找不到数据,则以null填充。

    --左外连接 left [outer] join  .... ON...
    select * from emp
     left join dept
     on emp.deptno = dept.deptno;
    
    on也可以换位using()

             5.自连接

                  同一个表里面的数据相关联

    --查询所有的员工的姓名和上级领导的姓名  emp(内连接)
    select e1.ename ename ,e2.ename mgrname from emp e1,emp e2
    where e1.mgr=e2.empno
    
    select e1.ename ename ,e2.ename mgrname from emp e1
    left join emp e2
    on e1.mgr=e2.empno
    •  子查询(嵌套查询)

            1.单行子查询

                 子查询的结果返回一行

    select dname from dept where deptno = (select deptno from emp where empno=7788);

            2.多行子查询

                 查询的结果返回一个集合

    --查询工资大于2000的员工的部门名称
      select dname from dept where deptno =any(select deptno from emp where sal > 2000);
      ANY   ALL
      =ANY 含义就是in   >any  大于最小值   <any  小于最大值
      >all 大于最大值    <all 小于最小值

            案例:

    --查询大于所在部门的平均工资的员工信息。
      --关联查询
       1.分组每个部门平均工资
       select * from emp e,(select deptno,avg(sal) avg from emp group by deptno) e1
       where e.deptno = e1.deptno and e.sal > e1.avg
      --子查询(主查询可以将数据传递给子查询)
       select * from emp e where sal > (select avg(sal) from emp e1 where e1.deptno = e.deptno)
       1.先执行主查询,将deptno传给子查询
       2.子查询拿到deptno,计算查询的结果,返回给主查询
       3.主查询拿到子查询返回的结果执行查询
    
    --查询薪水大于2000  emp 的部门名称  dept
    
       select dname from dept where deptno in(
       select deptno from emp where sal > 2000);
       
       select dname from dept d where EXISTS(
       select * from emp e where sal > 2000 and d.deptno = e.deptno)
    

               in和exists的区别

               1.IN
                  主查询的条件字段和子查询返回字段必须一致。
                  先执行子查询,将返回子查询的结果给主查询,再执行主查询
               2.EXISTS
                  主查询不需要出现条件字段
                  先执行主查询,将主查询的表的字段传给子查询,如果在子查询找到相应结果,
                  返回true,将该结果显示在结果集中。否则返回false
    •   联合查询

                 1.UNION

                     并集,所有的内容都查询,重复的显示一次

    select * from emp where deptno = 20 
    union   
    select * from emp where sal > 2000

                 2.UNION ALL

                     并集,所有的内容都显示,包括重复的

    • 事务

    •      存储引擎

           Mysql的核心就是存储引擎,DBMS借助于引擎实现增删改查操作。

           Mysql有多种存储引擎,不同引擎在事务的支持,查询的效率,索引策略等方面有不同。

           InnoDB是事务型数据库的首选,执行安全性数据库,行锁定和外键。mysql5.5之后默认使用。

           MyISAM插入速度和查询效率较高,但不支持事务。

           MEMORY将表中的数据存储在内存中,速度较快。

          

    •  什么是事务

          事务指逻辑上的一组操作,组成这组操作的各个单元,要么全成功,要么全不成功。

    •  事务的ACID特性

          原子性:指事务是一个不可分割的工作单位,事务中的操作要么都发生,要么都不发生。 

          一致性:事务必须使数据库从一个一致性状态变换到另外一个一致性状态。转账前和转账后的总金额不变。

          隔离性:事务的隔离性是多个用户并发访问数据库时,数据库为每一个用户开启的事务,不能被其他事务的操作数据所干扰,多个并发事务之间要相互隔离。

          持久性:指一个事务一旦被提交,它对数据库中数据的改变就是永久性的,接下来即使数据库发生故障也不应该对其有任何影响。

    •  事务的实现  tcl commit rollback

            查看事务  show variables like '%autocommit%'

            a)mysql数据库默认是自动提交

                set autocommit=0; 不自动提交

                set autocomiit=1;自动提交

            b)手动开启事务

                 start transaction/begin;

            c)手动提交或则回滚

                 commit;

                 rollback;

                 savepoint;保存点,恢复必须在事务提交之前。事务一旦提交,所有的保存点全部失效。

              注意:DDL操作会隐式事务提交

    -- 关闭自动提交
    set autocommit=0;
    -- 显式开始事务
    start TRANSACTION; 
    -- DML
    update account set money = money - 20 where name = 'ls';
    -- 保存点
    -- SAVEPOINT a;
    delete from aa;
    update account set money = money + 20 where name = 'zs';
    -- 提交
    -- commit;
    -- 回滚
    commit;
    -- 不起效
    -- ROLLBACK to a;
    
    •  JDBC如何控制事务

     

    •  事物的隔离级别

               赃读:指一个事务读取了另一个事务未提交的数据。

              不可重复读:在一个事务内读取表中的某一行数据,多次读取结果不同。一个事务读取到了另一个事务提交后的数据。(update)

               虚读(幻读):是指在一个事务内读取到了别的事务插入的数据,导致前后读取不一致。              (insert)

     

              数据库通过设置事务的隔离级别防止以上情况的发生:

               * 1、READ UNCOMMITTED: 赃读、不可重复读、虚读都有可能发生。

               * 2、READ COMMITTED: 避免赃读。不可重复读、虚读都有可能发生。(oracle默认的)

               * 4、REPEATABLE READ:避免赃读、不可重复读。虚读有可能发生。(mysql默认)

              * 8、SERIALIZABLE: 避免赃读、不可重复读、虚读。

               级别越高,性能越低,数据越安全

     

               mysql中:

               查看当前的事务隔离级别:SELECT @@TX_ISOLATION;

               更改当前的事务隔离级别:SET TRANSACTION ISOLATION LEVEL 四个级别之一。

               设置隔离级别必须在事务之前

     

     

    •  JDBC控制事务的隔离级别

         Connection接口:

         

         设置隔离级别:必须在开启事务之前。

         Connection.setTransactionIsolation(int level);

    •  存储程序

    •  概念:存储程序指的一组存储和执行在数据库服务器端的程序。
    •  分类    1.存储过程   2.存储函数  3.触发器
    •  存储过程

              1.基本语法

    CREATE PROCEDURE sel_emp(参数列表)
        BEGIN
         --操作
      END;

             2.使用

    无参的存储过程:
    CREATE PROCEDURE sel_emp()
        BEGIN
         select * from emp where deptno = 10;
      END;
    --存储过程的调用
    call sel_emp();
    
    有参的存储过程:
    --根据部门编号查询员工信息
      CREATE PROCEDURE sel_emp2(dno int)
      BEGIN
        select * from emp where deptno=dno;
      END;
     --调用存储过程
      call sel_emp2(30);
    
    --根据员工编号查询员工的名称
      CREATE PROCEDURE sel_emp3(eno int,OUT name varchar(20))
      BEGIN
        select ename into name from emp where empno=eno;
      end;
      --调用
      call sel_emp3(7788,@name);
      select @name;
    
    --根据员工编号查询所在部门的编号
      CREATE PROCEDURE sel_emp4(INOUT eno int)
      BEGIN
        select deptno into eno from emp where empno = eno;
      END;
        
      --调用
      set @eno = 7788;
      call sel_emp4(@eno);
      select @eno;
    
    --分支语句
    CREATE PROCEDURE cal_score(score int)
            BEGIN
            -- 声明变量
            DECLARE levels varchar(20);
            -- 分支
                    IF score >= 90 THEN
              -- 赋值
              set levels = '优秀';
            ELSEIF score >= 80  THEN
              set levels = '良好';
            ELSE
              set levels = '不通过';
            END IF;
            -- 输出
            select levels;
    END;
    
    --while循环
    create PROCEDURE calc()
      BEGIN
        -- 声明两个变量
        DECLARE sum int;
        DECLARE count int;
        -- 初始化
        set sum = 0;
        set count = 1;
        -- 循环
        while count <=100 DO
          set sum = sum + count;
          set count = count + 1;
        END WHILE;
    
        SELECT sum;
      END;
    
      --LOOP
      create PROCEDURE calc1()
      BEGIN
        -- 声明两个变量
        DECLARE sum int;
        DECLARE count int;
        -- 初始化
        set sum = 0;
        set count = 1;
        -- 循环
       lip:LOOP
          set sum = sum + count;
          set count = count + 1;
          IF count > 100 THEN
            LEAVE lip;
          END IF;
       END LOOP;
        SELECT sum;
      END;
        
    call calc1();
    
    create PROCEDURE calc3()
      BEGIN
        -- 声明两个变量
        DECLARE sum int;
        DECLARE count int;
        -- 初始化
        set sum = 0;
        set count = 1;
        -- 循环
       REPEAT
          set sum = sum + count;
          set count = count + 1;
          UNTIL count > 100
       END REPEAT;
        SELECT sum;
      END;
    

             3.参数模式

                 in:外部传进存储过程

                 out:传出

                 inout:传进传出

            4.游标

    --查询所有员工的姓名
      create PROCEDURE emp_cursor4()
      BEGIN
        DECLARE name varchar(20);
        DECLARE DONE boolean default 0;
        -- 声明游标类型变量存储所有员工的名称
        DECLARE emp_cursor CURSOR for select ename from emp;  
        -- 结束设置状态码为1  
        DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET DONE = 1;  
        -- 打开游标
        open emp_cursor;
        -- 获取游标中维护的值
        lip:LOOP
          FETCH emp_cursor into name;
          IF DONE THEN
            leave lip;
          END IF;
          select name;
        END LOOP;
        -- 关闭游标
        close emp_cursor;
      END;
    •  存储函数
    --函数(确定的不变的 DETERMINISTIC  Not )
      create FUNCTION emp_func()
      RETURNS VARCHAR(20)
    DETERMINISTIC
      BEGIN
         DECLARE name varchar(20);
         select ename into name from emp where empno = 7788;
         RETURN name;
      END;
    
      select emp_func();
    
    函数有返回值  return
    存储过程可以单独使用;但是函数只能作为语句的一部分。

     

     

    展开全文
  • 主要介绍了tp5.1 框架数据库高级查询技巧,结合实例形式总结分析了tp5.1 框架数据库快捷查询、区间查询、批量查询、闭包查询等相关高级查询使用技巧,需要的朋友可以参考下
  • 自定义高级查询Extjs

    2015-07-03 08:23:10
    自定义高级查询Extjs
  • MySQL高级查询详细.ppt

    2012-09-05 16:22:56
    本课程主要介绍了MySQL数据库的安装,管理,数据类型,SQL语句语法和使用,高级查询等方面的知识, 以应用为目标,具有较强的实践性。 大纲: 聚合函数 分组查询 联合查询 连接查询 子查询
  • Re: MySQL 查询与高级查询(多表、嵌套和正则表达式)  (查询的能力,显示DBA的功力) ============================================= 数据库管理系统的个最重要的功能就是数据查询,数据查询不应只是简单...
  • 数据库实验:数据库高级查询

    千次阅读 2020-06-10 23:58:49
    数据库实验:数据库高级查询 实验过程 (1) IN 嵌套查询 (2) 单层EXISTS 嵌套查询 (3) FROM 子句中的嵌套查询 (4) 集合查询(交) (5) 集合查询(并) (6) 集合查询(差) 1. 实验目的 掌握SQL ...

    数据库实验:数据库高级查询

    实验过程

    (1) IN 嵌套查询

    (2) 单层EXISTS 嵌套查询

    (3) FROM 子句中的嵌套查询

    (4) 集合查询(交)

    (5) 集合查询(并)

    (6) 集合查询(差)


    1. 实验目的

    掌握SQL 嵌套查询和集合查询等各种高级查询的设计方法等。

    2. 实验内容及要求

    针对TPC-H 数据库,正确分析用户查询要求,设计各种嵌套查询和集合查询。

    3. 实验重点和难

    实验重点:嵌套查询

    实验难点:相关子查询、多层EXIST 嵌套查询。

    4、实验过程

    (1) IN 嵌套查询

    查询订购了“海大”制造的“船舶模拟驾驶舱”的顾客。

    涉及Customer, Orders, Lineitem, PartSupp, Part

    SELECT *
    
    FROM Customer C
    
    WHERE C.Cukekey IN(
    
      SELECT O.Custkey
    
      FROM Orders O,PartSupp PS,Supplier S,Part P,Lineitem L
    
      WHERE S.Name = '海大' AND
    
      P.Name = '船舶模拟驾驶舱' AND
    
      P.Partkey = L.Partkey AND
    
      L.Suppkey = S.Suppkey)

     

    (2) 单层EXISTS 嵌套查询

    查询没有购买过“海大”制造的“船舶模拟驾驶舱”的顾客。

    涉及Customer, Orders, Lineitem, PartSupp, Part

    SELECT *
    
    FROM Customer
    
    WHERE NOT EXISTS
    
      (SELECT*
    
       FROM Part P,Supplier S,Lineitem L,Orders O,Customer C
    
       WHERE P.Name = '船舶驾驶模拟' AND
    
       S.Name = '海大' AND
    
       L.Partkey = P.Partkey AND
    
       S.Suppkey = L.Suppkey AND
    
       L.Orderkey = O.Orderkey AND
    
       O.Custkey = C.Custkey)   

     

    (3) FROM 子句中的嵌套查询

    查询订单平均金额超过1 万元的顾客中的中国籍顾客信息。

    涉及Customer, Orders

    SELECT C.*
    
    FROM Customer C,(
    
      SELECT Custkey
    
      FROM Orders
    
      GROUP BY Custkey
    
      Having AVG(Totalprice)>10000) B,Nation N
    
    WHERE C.Custkey = B.Custkey AND
    
    C.Nationkey = N.Nationkey AND N.Name = '中国'

     

    (4) 集合查询(交)

    查询顾客“张三”和“李四”都订购过的全部零件信息。

    涉及Customer, Orders, Lineitem, PartSupp, Part

    SELECT p.*
    
    FROM Part P,Customer C,Orders O,Lineitem L,PartSupp PS
    
    WHERE C.Name = '张三' AND
    
    C.Custkey = O.Custkey AND
    
    O.Orderkey = L.Orderkey AND
    
    L.Suppkey = PS.Suppkey AND
    
    L.Partkey = PS.Partkey AND
    
    PS.Partkey = P.Partkey;
    
    INTERSECT –- 交操作
    
    SELECT p.*
    
    FROM Part P,Customer C,Orders O,Lineitem L,PartSupp PS
    
    WHERE C.Name = '李四' AND
    
    C.Custkey = O.Custkey AND
    
    O.Orderkey = L.Orderkey AND
    
    L.Suppkey = PS.Suppkey AND
    
    L.Partkey = PS.Partkey AND
    
    PS.Partkey = P.Partkey;

     

    (5) 集合查询(并)

    查询顾客“张三”和“李四”订购的全部零件的信息。

    涉及Customer, Orders, Lineitem, PartSupp, Part

    SELECT p.*
    
    FROM Part P,Customer C,Orders O,Lineitem L,PartSupp PS
    
    WHERE C.Name = '张三' AND
    
    C.Custkey = O.Custkey AND
    
    O.Orderkey = L.Orderkey AND
    
    L.Suppkey = PS.Suppkey AND
    
    L.Partkey = PS.Partkey AND
    
    PS.Partkey = P.Partkey;
    
    UNION –- 并操作
    
    SELECT p.*
    
    FROM Part P,Customer C,Orders O,Lineitem L,PartSupp PS
    
    WHERE C.Name = '李四' AND
    
    C.Custkey = O.Custkey AND
    
    O.Orderkey = L.Orderkey AND
    
    L.Suppkey = PS.Suppkey AND
    
    L.Partkey = PS.Partkey AND
    
    PS.Partkey = P.Partkey;
    
    


     

    (6) 集合查询(差)

    查询顾客“张三”订购过而“李四”没有订购过的零件的信息。

    涉及Customer, Orders, Lineitem, PartSupp, Part

    SELECT p.*
    
    FROM Part P,Customer C,Orders O,Lineitem L,PartSupp PS
    
    WHERE C.Name = '张三' AND
    
    C.Custkey = O.Custkey AND
    
    O.Orderkey = L.Orderkey AND
    
    L.Suppkey = PS.Suppkey AND
    
    L.Partkey = PS.Partkey AND
    
    PS.Partkey = P.Partkey;
    
    EXCEPT –- 差操作
    
    SELECT p.*
    
    FROM Part P,Customer C,Orders O,Lineitem L,PartSupp PS
    
    WHERE C.Name = '李四' AND
    
    C.Custkey = O.Custkey AND
    
    O.Orderkey = L.Orderkey AND
    
    L.Suppkey = PS.Suppkey AND
    
    L.Partkey = PS.Partkey AND
    
    PS.Partkey = P.Partkey;

     

     

    二、实验效果及分析

    这次实验主要内容是数据查询,涉及到了嵌套查询和集合操作的使用,较之基本查询技巧性更强,实现的功能更复杂。

    嵌套查询使用关键字IN,判断某数据是否属于查询结果集合;也使用EXISTS/NOT EXISTS,判断数据元组是否满足某查询结果;使用FROM子句嵌套,直接将查询结果作为一个表处理。同时,嵌套查询往往和聚集函数、连接查询配合使用。

    集合操作的方法,将两个查询结果作为结果,可以找到它们的并、交、差集合,从而找到满足条件的数据集合。

     

    展开全文
  • 【Spring Data ElasticSearch】高级查询,聚合1. 高级查询1.1 基本查询1.2 自定义查询1.3 分页查询1.4 排序2. 聚合2.1 聚合为桶2.2 嵌套聚合,求平均值 1. 高级查询 1.1 基本查询 package com.siyi.elasticsearch; ...

    1. 高级查询

    1.1 基本查询

    package com.siyi.elasticsearch;
    
    import com.siyi.elasticsearch.pojo.Item;
    import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
    
    import java.util.List;
    
    public interface ItemRepository extends ElasticsearchRepository<Item,Long> {
    
    }
    
    @Test
    public void testQuery(){
        // 词条查询
        MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("title", "小米");
        // 执行查询
        Iterable<Item> items = this.itemRepository.search(queryBuilder);
        items.forEach(System.out::println);
    }
    

    Repository的search方法需要QueryBuilder参数,elasticSearch为我们提供了一个对象QueryBuilders:
    在这里插入图片描述

    QueryBuilders提供了大量的静态方法,用于生成各种不同类型的查询对象,例如:词条、模糊、通配符等QueryBuilder对象。

    lasticsearch提供很多可用的查询方式,但是不够灵活。如果想玩过滤或者聚合查询等就很难了。
    所以我们需要自定义查询。

    1.2 自定义查询

    	@Test
    	public void testNativeQuery(){
    	    // 构建查询条件
    	    NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
    	    // 添加基本的分词查询
    	    queryBuilder.withQuery(QueryBuilders.matchQuery("title", "小米"));
    	    // 执行搜索,获取结果
    	    Page<Item> items = this.itemRepository.search(queryBuilder.build());
    	    // 打印总条数
    	    System.out.println(items.getTotalElements());
    	    // 打印总页数
    	    System.out.println(items.getTotalPages());
    	    items.forEach(System.out::println);
    	}
    

    NativeSearchQueryBuilder:Spring提供的一个查询条件构建器,帮助构建json格式的请求体

    Page<item>:默认是分页查询,因此返回的是一个分页的结果对象,包含属性:

    • totalElements:总条数
    • totalPages:总页数
    • Iterator:迭代器,本身实现了Iterator接口,因此可直接迭代得到当前页的数据
    • 其它属性:

    1.3 分页查询

    利用NativeSearchQueryBuilder可以方便的实现分页:

    @Test
    public void testNativeQuery(){
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 添加基本的分词查询
        queryBuilder.withQuery(QueryBuilders.termQuery("category", "手机"));
    
        // 初始化分页参数
        int page = 0;
        int size = 3;
        // 设置分页参数
        queryBuilder.withPageable(PageRequest.of(page, size));
    
        // 执行搜索,获取结果
        Page<Item> items = this.itemRepository.search(queryBuilder.build());
        // 打印总条数
        System.out.println(items.getTotalElements());
        // 打印总页数
        System.out.println(items.getTotalPages());
        // 每页大小
        System.out.println(items.getSize());
        // 当前页
        System.out.println(items.getNumber());
        items.forEach(System.out::println);
    }
    

    注意:elasticsearch分页是从0开始的。

    1.4 排序

    排序也通用通过NativeSearchQueryBuilder完成:

    @Test
    public void testSort(){
        // 构建查询条件
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 添加基本的分词查询
        queryBuilder.withQuery(QueryBuilders.termQuery("category", "手机"));
    
        // 排序
        queryBuilder.withSort(SortBuilders.fieldSort("price").order(SortOrder.DESC));
    
        // 执行搜索,获取结果
        Page<Item> items = this.itemRepository.search(queryBuilder.build());
        // 打印总条数
        System.out.println(items.getTotalElements());
        items.forEach(System.out::println);
    }
    

    2. 聚合

    2.1 聚合为桶

    桶就是分组,比如这里我们按照品牌brand进行分组:

    @Test
    public void testAgg(){
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 不查询任何结果
        queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{""}, null));
        // 1、添加一个新的聚合,聚合类型为terms,聚合名称为brands,聚合字段为brand
        queryBuilder.addAggregation(
            AggregationBuilders.terms("brands").field("brand"));
        // 2、查询,需要把结果强转为AggregatedPage类型
        AggregatedPage<Item> aggPage = (AggregatedPage<Item>) this.itemRepository.search(queryBuilder.build());
        // 3、解析
        // 3.1、从结果中取出名为brands的那个聚合,
        // 因为是利用String类型字段来进行的term聚合,所以结果要强转为StringTerm类型
        StringTerms agg = (StringTerms) aggPage.getAggregation("brands");
        // 3.2、获取桶
        List<StringTerms.Bucket> buckets = agg.getBuckets();
        // 3.3、遍历
        for (StringTerms.Bucket bucket : buckets) {
            // 3.4、获取桶中的key,即品牌名称
            System.out.println(bucket.getKeyAsString());
            // 3.5、获取桶中的文档数量
            System.out.println(bucket.getDocCount());
        }
    }
    

    关键API:

    • AggregationBuilders:聚合的构建工厂类。所有聚合都由这个类来构建,看看他的静态方法:

      • AggregatedPage:聚合查询的结果类。它是Page<T>的子接口:
        在这里插入图片描述

      AggregatedPagePage功能的基础上,拓展了与聚合相关的功能,它其实就是对聚合结果的一种封装,大家可以对照聚合结果的JSON结构来看。

      而返回的结果都是Aggregation类型对象,不过根据字段类型不同,又有不同的子类表示

      我们看下页面的查询的JSON结果与Java类的对照关系:

    2.2 嵌套聚合,求平均值

    @Test
    public void testSubAgg(){
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        // 不查询任何结果
        queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{""}, null));
        // 1、添加一个新的聚合,聚合类型为terms,聚合名称为brands,聚合字段为brand
        queryBuilder.addAggregation(
            AggregationBuilders.terms("brands").field("brand")
            .subAggregation(AggregationBuilders.avg("priceAvg").field("price")) // 在品牌聚合桶内进行嵌套聚合,求平均值
        );
        // 2、查询,需要把结果强转为AggregatedPage类型
        AggregatedPage<Item> aggPage = (AggregatedPage<Item>) this.itemRepository.search(queryBuilder.build());
        // 3、解析
        // 3.1、从结果中取出名为brands的那个聚合,
        // 因为是利用String类型字段来进行的term聚合,所以结果要强转为StringTerm类型
        StringTerms agg = (StringTerms) aggPage.getAggregation("brands");
        // 3.2、获取桶
        List<StringTerms.Bucket> buckets = agg.getBuckets();
        // 3.3、遍历
        for (StringTerms.Bucket bucket : buckets) {
            // 3.4、获取桶中的key,即品牌名称  3.5、获取桶中的文档数量
            System.out.println(bucket.getKeyAsString() + ",共" + bucket.getDocCount() + "台");
    
            // 3.6.获取子聚合结果:
            InternalAvg avg = (InternalAvg) bucket.getAggregations().asMap().get("priceAvg");
            System.out.println("平均售价:" + avg.getValue());
        }
    }
    

    展开全文
  • 【JEECG技术文档】Jeecg高级查询

    千次阅读 2018-02-07 12:02:41
    1. 背景 对于用户来讲查询功能按易用性分三个层次: 1)最简单查询操作是一个输入框,全文检索,如百度,后台实现技术使用搜索引擎,需要设计和建立索引,技术较为复杂,适用于文档和信息数据库检索,但是结果很...
  • 实现后台高级查询(高级版)

    千次阅读 2018-01-04 19:19:38
    //商品的高级查询对象,封装了商品高级查询表单的数据。 public class ProductQueryObject extends BaseQueryObject{ private List conditions = new ArrayList(); //拼接查询条件的SQL public String getQuery
  • oracle_高级查询

    2012-10-29 14:48:20
    oracle_高级查询,使用oracle数据库最终上升到高级用法
  • web高级查询+分页

    2013-08-13 15:56:09
    基于三大框架struts2+Hibernate+Spring的使用session的高级查询和分页~
  • 数据库-高级查询

    千次阅读 2018-09-26 17:00:44
    EXISTS子查询 Exists子查询就是用来判断某些条件是否满足(跨表),Exists是接在where之后,Exists返回的结果只有0和1。 EXISTS子查询的语法 SELECT …… FROM 表名 WHERE EXISTS(子查询); 子查询有返回...
  • Mysql高级查询

    千次阅读 2019-02-22 19:22:46
    高级查询(连接查询):查询多张表或者结果集 结果连接 等值连接 非等值连接 内连接:内外键互换不会影响结果集,哪个表在前面哪个表的内容就在前面,显示两者共有的 外连接:内外键互换会影响结果集,显示第一...
  • MySQL高级查询

    千次阅读 2018-09-13 13:36:59
    高级查询 高级查询的格式: select ... 聚合函数 from 表名 where ... group by ... having ... order by ... limit ... order by 给查询结果排序 语法格式: ... order by 字段名 ASC/DESC; ASC:默认,...
  • Elasticsearch 实战 - 第四讲:ES 高级查询一、高级查询1、简介2、结果排序3、分页查询4、检索查询5、关键字查询6、高亮显示7、逻辑查询8、过滤查询 一、高级查询 1、简介 Elasticsearch基于JSON提供完整的查询DSL...
  • 1. 高级查询构造器管理功能介绍 高级查询构造器支持主子表联合查询,查询出更精确的数据。要使用高级查询构造器需要完成以下步骤: 1. 在高级查询管理配置主子表信息。 2. 配置完后在JSP页面DataGrid标签上...
  • 实验3-高级查询.doc

    2020-09-07 06:47:52
    实验三 高级查询 实验目的 掌握SQL的高级查询的使用方法如分组统计嵌套查询集合查询等等 实验内容 掌握SQL高级查询使用方法 分组统计 嵌套查询包括IN查询EXISTS查询 集合查询 实验要求 深入复习教材第三章SQL有关...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 339,713
精华内容 135,885
关键字:

高级查询