精华内容
下载资源
问答
  • Oracle复杂查询实验报告, 用SQL语句实现下列查询。要求:能用嵌套查询的尽量使用嵌套查询。
  • SQL数据库实验四_复杂查询(1)解答.doc
  • 实验四 复杂查询

    千次阅读 多人点赞 2020-11-01 21:34:23
    实验四 复杂查询 教材使用的是雷景生版本的《数据库原理及应用(第2版)》 一、 实验目的: 掌握两个表以上的连接查询的应用,包括嵌套查询。 二、 实验内容: 初始表格三张: Student表、Course表和SC表 1、 ...

    实验四 复杂查询

    教材使用的是雷景生版本的《数据库原理及应用(第2版)》

    一、 实验目的:
    掌握两个表以上的连接查询的应用,包括嵌套查询。

    二、 实验内容:
    初始表格三张:
    Student表、Course表和SC表
    Student
    Course
    SC

    1、 同一数据库中的多表查询
    (1) 查询比“林红”年纪大的男学生的信息。

    select *
    from Student 
    where Sex ='男'
    and Birth < any
    (select Birth 
    from Student
    where Sname='林红')
    //这里的思路是先提取(或者叫做查询)林红的生日再使用比较运算符
    

    结果:
    在这里插入图片描述
    为空,因为没有比林红年龄大的男同学
    ·
    ·
    ·
    (2) 查询所有学生的选课信息,包括学号、姓名、课号、课程名、成绩。

    select Student.Sno,Sname,Course.Cno,Cname,Grade
    from Student,Course,SC  
    where Student.Sno=SC.Sno and Course.Cno=SC.Cno
    

    结果:
    在这里插入图片描述
    这里要注意的是,如果代码的where后没有用自然连接的话会出现如下的数据冗杂情况(会变成三张表的笛卡尔乘积)
    在这里插入图片描述
    ·
    ·
    ·
    (3) 查询已选课学生的学号、姓名、课程名、成绩。

    select SC.Sno,Student.Sname,Cname,Grade
    from SC left outer join Student on(student.sno=sc.sno),Course 
    where Course.Cno=SC.Cno 
    

    结果:
    在这里插入图片描述
    ·
    ·
    ·
    (4) 查询选修了“C语言程序设计”的学生的学号和姓名。

    select Student.Sno,Sname
    from Student,SC 
    where Student.Sno=SC.Sno and SC.Cno in 
    (select Cno
    from Course
    where Cname='C语言程序设计')
    
    

    结果:
    在这里插入图片描述
    ·
    ·
    ·
    (5) 查询与“张虹”在同一个班级的学生的学号、姓名、家庭住址。

    select Sno,Sname,Home_addr 
    from Student 
    where Classno in
    (select Classno 
    from Student 
    where Sname='张虹')
    

    结果:
    在这里插入图片描述
    ·
    ·
    ·
    (6) 查询其他班级中比“051”班所有学生年龄大的学生的学号、姓名。

    select Sno,Sname  
    from Student 
    where Classno <>'051'
    and Birth<all(select Birth  
                  from Student 
                  where Classno='051') 
    

    结果:
    在这里插入图片描述
    ·
    ·
    ·
    (7) (选做)查询选修了全部课程的学生的姓名。
    方法一:

    select Sname
    from Student
    where Sno in
    (select Sno from SC
    group by Sno
    having count(*) = (select count(*) from Course ))
    

    结果:
    在这里插入图片描述
    方法二:

    select Sname 
    from Student
    where not exists 
    (select *
    from Course
    where not exists
              (select *
    		   from SC
    		   where Student.Sno=SC.Sno
    		   and Course.Cno=SC.Cno))             
    

    结果:
    在这里插入图片描述
    ·
    ·
    ·
    (8) (选做)查询至少选修了学生“20110002”选修的全部课程的学生的学号、姓名。
    方法一:

    select Student.Sno,Sname
    from Student,SC
    where Student.Sno=SC.Sno 
    and Cno =
    (select Cno from SC
    where Sno='20110002')   
    

    结果:
    在这里插入图片描述
    方法二:

    select distinct sx.Sno,Sname
    from SC sx left outer join Student on(sx.Sno =Student.Sno )
    where not exists
    (select * 
    from SC sy
    where sy.Sno ='20110002'and
    not exists
    (select * from SC sz
    where sz.Cno=sy.Cno
    and sz.Sno=sx.Sno) )   
    

    结果:
    在这里插入图片描述
    ·
    ·
    ·
    (9) 查询学生的学号、姓名、学习课程名及课程成绩。

    select Student.Sno,Sname,Cname,Grade
    from Student,Course,SC 
    where Student.Sno=SC.Sno and Course.Cno=SC.Cno
    

    结果:
    在这里插入图片描述
    ·
    ·
    ·
    (10) 查询选修了“高数”课且成绩至少高于选修课程号为“002”课程的学生的学号、课程号、成绩,并按成绩从高到低排列。

    select Sno,Cno,Grade
    from SC
    where Cno in(select Cno from Course 
                 where Cname='高数' )
    and Grade >all(select Grade from SC 
                   where Cno='002')
    order by Grade desc
    

    结果:
    在这里插入图片描述
    ·
    ·
    ·
    (11) 查询选修3门以上课程的学生的学号、总成绩(不统计不及格的课程),并要求按总成绩的降序排列出来。

    select Sno,sum(case when Grade>=60 then grade else 0 end)as'allg'
    from SC 
    where Sno in
    (select Sno from SC group by Sno having count(*)>3)
    group by Sno 
    order by allg desc 
    

    结果:
    在这里插入图片描述
    ·
    ·
    ·
    (12) 查询多于3名学生选修的并以3结尾的课程号的平均成绩。

    select Cno,AVG(Grade)as 'pingjun' 
    from SC
    where Cno in
    (select Cno from SC group by Cno having COUNT(*)>3)      
    and Cno='%3'
    group by Cno                                               
    

    结果:
    在这里插入图片描述

    ·
    ·
    ·
    (13) 查询最高分与最低分之差大于5分的学生的学号、姓名、最高分、最低分。

    select SC.Sno,Sname,MAX(Grade),MIN(Grade)
    from SC,Student
    where SC.Sno in
    (select Sno 
    from SC 
    group by Sno
    having COUNT(*)>2 
    and MAX(Grade)-MIN(Grade)>5)   
    and SC.Sno=Student.Sno    
    group by SC.Sno,Sname             
    

    结果:
    在这里插入图片描述

    ·
    ·
    ·
    (14) 创建表Studen_other,结构同Student,输人若干记录,部分记录和Student表中的相同。
    创建Student_other表如下:
    在这里插入图片描述
    ①查询同时出现在Student表和Student_other表中的记录。

    select * from Student
    intersect
    select * from Student_other
    

    结果:
    在这里插入图片描述

    ②查询Student表和Student_other表中的全部记录。

    select * from Student
    select * from Student_other
    

    结果:在这里插入图片描述
    2、多个数据库间的多表查询
    (选做)创建一个数据库Student_info_other,参数自定。
    (1)当前数据库为Student_info,将Student_info数据库中的表Student_other复制到Student_info_other 中。
    (2)查询同时出现在Student表和Student_info__other 数据库Student_other表中的记录。

    3、外连接查询
    (1)查询所有课程信息及其选课信息,包含未被学生选修的课程。

    select * 
    from Course left outer join SC on(Course.Cno=SC.Cno )
    

    结果:
    在这里插入图片描述
    (2)查询所有学生信息,所有课程信息及其选课信息,包含未选修课程的学生及未被学生选修的课程。

    select  * 
    from Student 
    left join SC on (Student.Sno=SC.Sno)
    left join Course on(SC.Cno=Course.Cno)
    

    结果:
    在这里插入图片描述

    展开全文
  • 9. MyBatisPlus实现复杂查询

    千次阅读 2020-10-18 10:47:51
    文章目录MyBatisPlus实现复杂查询1. wapper介绍2. AbstractWrapper2.1 ge、gt、le、lt、isNull、isNotNull2.2 eq、ne2.3 between、notBetween2.4 allEq2.5 like、notLike、likeLeft、likeRight2.6 in、notIn、inSql...

    MyBatisPlus实现复杂查询

    在这里插入图片描述

    1. wapper介绍

    • Wrapper : 条件构造抽象类,最顶端父类。
      • AbstractWrapper : 用于查询条件封装,生成 sql 的 where 条件。
        • QueryWrapperEntity 对象封装操作类,不是用lambda语法
        • UpdateWrapper : Update 条件封装,用于Entity对象更新操作。
        • AbstractLambdaWrapper : Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。
        • LambdaQueryWrapper :看名称也能明白就是用于Lambda语法使用的查询Wrapper
        • LambdaUpdateWrapper : Lambda 更新封装Wrapper

    在这里插入图片描述

        @RunWith(SpringRunner.class)
        @SpringBootTest
        public class QueryWrapperTests {
    
            @Autowired
            private UserMapper userMapper;
        }
    

    2. AbstractWrapper

    1. 注意:以下条件构造器的方法入参中的 column均表示数据库字段
    2. 以下查询条件都是在AbstractWrapper中定义的。

    2.1 ge、gt、le、lt、isNull、isNotNull

        /**
         * ge 大于等于
         * gt 大于
         * le 小于等于
         * lt 小于
         * isNull 是null
         * isNotNull 不是nul
         * 执行的也是逻辑删除
         */
        @Test
        public void testDelete() {
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            queryWrapper.isNull("create_time").ge("age", 21).isNotNull("email");
            
            int result = userMapper.delete(queryWrapper);
            System.out.println("result = " + result);
        }
    

    2.2 eq、ne

    **注意:**seletOne返回的是一条实体记录,当出现多条时会报错

        /**
         * selectOne返回的是一条实体记录,当出现多条时会报错
         * eq 等于
         * ne 不等于
         */
        @Test
        public void testSelectOne(){
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("name","Sandy");
            
            User user = userMapper.selectOne(queryWrapper);
            System.out.println("user = " + user);
        }
    

    2.3 between、notBetween

       /**
         * between 包含大小边界
         */
        @Test
        public void testSelectCount(){
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            
            queryWrapper.between("age",22,30);
            
            Integer count = userMapper.selectCount(queryWrapper);
            System.out.println("count = " + count);
        }
    

    2.4 allEq

        /**
         * allEq等于所有
         * select id,name,age,email,create_time,update_time,version,deleted from user where deleted=0 and name= 'HeMiao'and age = 28
         */
        @Test
        public void testSelctList(){
    
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            Map<String,Object> map = new HashMap<>();
            map.put("name","HeMiao");
            map.put("age",28);
            
            queryWrapper.allEq(map);
            List<User> users = userMapper.selectList(queryWrapper);
            users.forEach(System.out::println);
        }
    

    2.5 like、notLike、likeLeft、likeRight

    selectMaps返回Map集合列表

        /**
         * like
         * notLike
         * likeLeft
         * likeRight
         */
        @Test
        public void testSelectMaps(){
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            queryWrapper.like("name","2");
            
            List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
            maps.forEach(System.out::println);
        }
    

    2.6 in、notIn、inSql、notinSql、exists、notExists

    in、notIn:

    inSql、notinSql:可以实现子查询

    • 例: inSql("age", "1,2,3,4,5,6")—>age in (1,2,3,4,5,6)
    • 例: inSql("id", "select id from table where id < 3")—>id in (select id from table where id < 3)

    2.7 or、and

    1. **注意:**这里使用的是 UpdateWrapper
    2. 不调用or则默认为使用 and
    @Test
    public void testUpdate1() {
    
        //修改值
        User user = new User();
        user.setAge(99);
        user.setName("Andy");
    
        //修改条件
        UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
        userUpdateWrapper
            .like("name", "h")
            .or()
            .between("age", 20, 30);
    
        int result = userMapper.update(user, userUpdateWrapper);
    
        System.out.println(result);
    }
    

    2.8 嵌套or、嵌套and

    这里使用了lambda表达式,or中的表达式最后翻译成sql时会被加上圆括号

    @Test
    public void testUpdate2() {
    
    
        //修改值
        User user = new User();
        user.setAge(99);
        user.setName("Andy");
    
        //修改条件
        UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
        userUpdateWrapper
            .like("name", "h")
            .or(i -> i.eq("name", "李白").ne("age", 20));
    
        int result = userMapper.update(user, userUpdateWrapper);
    
        System.out.println(result);
    }
    

    2.9 orderBy、orderByDesc、orderByAsc

       /**
         * orderBy
         * orderByDesc 降序
         * orderBYAsc  升序
         */
        @Test
        public void testSelectListOrderBy(){
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            queryWrapper.orderByDesc("id");
            
            List<User> users = userMapper.selectList(queryWrapper);
            users.forEach(System.out::println);
        }
    

    2.10 last

    1. 直接拼接到 sql 的最后
    2. 注意:只能调用一次,多次调用以最后一次为准 有sql注入的风险,请谨慎使用。
    @Test
    public void testSelectListLast() {
    
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.last("limit 1");
    
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }
    

    2.11 指定要查询的列

    • queryWrapper.select("id","name","age");
       @Test
        public void testSelectListColumn(){
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            
            queryWrapper.select("id","name","age");
            
            List<User> users = userMapper.selectList(queryWrapper);
            users.forEach(System.out::println);
        }
    

    2.12 set、setSql

    最终的sql会合并 user.setAge(),以及 userUpdateWrapper.set() 和 setSql() 中 的字段

    @Test
    public void testUpdateSet() {
    
        //修改值
        User user = new User();
        user.setAge(99);
    
        //修改条件
        UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
        userUpdateWrapper
            .like("name", "h")
            .set("name", "老李头")//除了可以查询还可以使用set设置修改的字段
            .setSql(" email = '123@qq.com'");//可以有子查询
    
        int result = userMapper.update(user, userUpdateWrapper);
    }
    

    展开全文
  • sql复杂查询例子大全

    2010-05-16 09:45:28
    sql复杂查询例子大全sql复杂查询例子大全
  • sql 复杂查询语句

    千次阅读 2020-05-02 10:52:19
    查询成绩高于该门课程平均分的学生的学号、姓名和成绩,写出相应的SQL查询语句 (课程表中只有学号,课程号,和成绩。每门课程的平均分需要另外计算) select S.studentNo,studentName,score from Student S join ...

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

    查询成绩高于该门课程平均分的学生的学号、姓名和成绩,写出相应的SQL查询语句

    (课程表中只有学号,课程号,和成绩。每门课程的平均分需要另外计算)

    select S.studentNo,studentName,score 
    	from Student S join Score on S.studentNo=Score.studentNo 
    	join Course on Course.courseNo=Score.courseNo 
    	join (select AVG(score) gg ,courseNo  /*求AVG得用子查询*/
    			from Score join student H on Score.studentNo=H.studentNo    
    			/*group by courseNo 把课程号相同的分到一组计算成绩的平均值,即每门课的平均分*/
    			group by courseNo) G on G.courseNo=Course.courseNo where score>gg 
    			/*把子查询的结果连接上去之后,每个不同的课程号都会有一个平均分,取分数大于平均分的*/
    

    查询结果:

    Ps:因为题目要求要输出成绩,所以这里会有一个学生输出多次的情况

    把子查询的结果连接上去之后,再加个where就可以解决复杂查询了

    展开全文
  • elasticsearch 的多条件分页查询以及聚合查询(带子查询

    一、回顾

    上回简单写了ES在springboot项目中的简单使用,elasticsearch(ES)在SpringBoot中的基本使用 ,介绍了es的基本概念以及基本的查询等,但是针对多条件分页查询或者聚合查询等,使用ElasticSearchRepository可能就有些力不从心了,需要借助更为强大的elasticsearchTemplate,本文首先介绍多条件的分页查询,然后介绍项目中常用的聚合统计查询等。

    二、ES复杂查询

    1)多条件分页查询

    由于是多条件的查询,再使用之前的TermQueryBuilder/MatchQueryBuilder等都不能满足要求了,需要使用多个条件混合的BoolQueryBuiler 进行查询,搜索查询也使用原生查询NativeSearchQuery进行查询。

    //    多条件分页查询
        public  PageModel<Book> multiConditionQuery(BookDto bookDto){
            String name = bookDto.getName();
            String mainType = bookDto.getMainType();
            List<Integer> pageNumList = bookDto.getPageNumList();
            Date startTime = bookDto.getStartTime();
            Date endTime = bookDto.getEndTime();
    //        分页
            Pageable page = PageRequest.of(bookDto.getPage()-1,bookDto.getPageSize());
    //      bool-查询
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            if(StringUtils.isNotBlank(name)){
                boolQueryBuilder.filter(QueryBuilders.termQuery("name",name));
            }
            if(StringUtils.isNotBlank(mainType)){
                boolQueryBuilder.filter(QueryBuilders.termQuery("mainType",mainType));
            }
            if(CollectionUtils.isNotEmpty(pageNumList)){
                boolQueryBuilder.filter(QueryBuilders.termsQuery("pageNum",pageNumList));
            }
            if(startTime != null){
                boolQueryBuilder.filter(QueryBuilders.rangeQuery("createTime").gte(DateUtil.formatESDate(startTime)));
            }
            if(endTime != null){
                boolQueryBuilder.filter(QueryBuilders.rangeQuery("createTime").lte(DateUtil.formatESDate(endTime)));
            }
    //        排序
            FieldSortBuilder createTimeSort = SortBuilders.fieldSort("createTime").order(SortOrder.DESC);
            NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
            NativeSearchQuery build = nativeSearchQueryBuilder.withQuery(boolQueryBuilder)
                                                              .withPageable(page)
                                                              .withSort(createTimeSort)
                                                               .build();
            AggregatedPage<Book> booksAgg = elasticsearchTemplate.queryForPage(build, Book.class);
            PageModel<Book> bookPageModel =
                    new PageModel<>(booksAgg.getContent(),bookDto.getPage(),bookDto.getPageSize(),booksAgg.getTotalElements());
            return bookPageModel;
        }

    2)聚合查询-带子聚合

    项目中,我们经常有统计一个大类以及该大类下面的小类数量的需求,比如以我们的Book实体为例,我们可能需要统计库中"文学” 大类下面的“小说”、“散文”、“诗歌”等子类各有多少本。为了更好地应用该功能,我们模拟“造”一些数据存入到es中,插入数据的示例如下,我们使用random随机插入一些数据,只不过每一项的枚举我们事前固定在数组中。

     @ApiOperation(value = "批量保存book数据")
        @RequestMapping(value = "/batchSave", method = RequestMethod.PUT)
        public String testSaveBook(@RequestParam Integer n) {
            Random random = new Random();
            String[] names = {"三国志", "三国演义", "三国", "红楼梦", "红楼", "西游记", "三国演义"};
            Integer[] pageNums = {100, 200, 300, 400, 500};
            String[] mainTypes = {"文学", "数学", "编程学", "法律学"};
            String[] subType0s = {"小说", "散文", "诗歌", "话剧"};
            String[] subType1s = {"代数", "几何"};
            String[] subType2s = {"Java", "c++", "python", "go"};
            String[] subType3s = {"民法", "刑法", "商法"};
            String[] introductions = {"这是一本很好的故事", "这里面有非常动人的故事", "孙悟空三大白骨精"};
            Double[] prices = {38.6, 35.8, 50.9, 40.7};
            for (int i = 0; i < n; i++) {
                Book b = new Book();
                String id = UUID.randomUUID().toString().replace("_", "").substring(0, 10);
                b.setId(id);
                b.setName(names[random.nextInt(names.length)]);
                b.setPageNum(pageNums[random.nextInt(pageNums.length)]);
                b.setPrice(prices[random.nextInt(prices.length)]);
                b.setIntroduction(introductions[random.nextInt(introductions.length)]);
                Integer mainTypeIndex = random.nextInt(mainTypes.length);
                b.setMainType(mainTypes[mainTypeIndex]);
    //          子类型数据插入
                switch (mainTypeIndex) {
                    case 0:
                        b.setSubType(subType0s[random.nextInt(subType0s.length)]);
                        break;
                    case 1:
                        b.setSubType(subType1s[random.nextInt(subType1s.length)]);
                        break;
                    case 2:
                        b.setSubType(subType2s[random.nextInt(subType2s.length)]);
                        break;
                    case 3:
                        b.setSubType(subType3s[random.nextInt(subType3s.length)]);
                        break;
                    default:
                        break;
                }
                b.setCreateTime(DateUtil.getOneDayOnset(random.nextInt(90), new Date()));
                System.out.println("========save book ======= " + i + " ok!");
                bookRepository.save(b);
            }
            return "ok";
        }

    然后我们就可以使用聚合查询统计出这些数据了,这里主要是在NativeSearchQuery中添加聚合查询,聚合查询类似MySQL中的group by 分组查询。

    /**
         * 聚合查询
         */
        public void aggQueryByMainType(BookDto bookDto){
            Date startTime = bookDto.getStartTime();
            Date endTime = bookDto.getEndTime();
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            if(startTime != null){
                boolQueryBuilder.filter(QueryBuilders.rangeQuery("createTime").gte(startTime));
            }
            if(endTime != null){
                boolQueryBuilder.filter(QueryBuilders.rangeQuery("createTime").lte(endTime));
            }
    //      聚合查询再聚合查询,双次聚合
            TermsAggregationBuilder fieldAgg = AggregationBuilders.terms("mainType").field("mainType");
            fieldAgg.subAggregation(AggregationBuilders.terms("subType").field("subType"));
    //       构建原生查询query
            NativeSearchQuery build = new NativeSearchQueryBuilder()
                    .addAggregation(fieldAgg)
                    .withQuery(boolQueryBuilder)
                    .withPageable(PageRequest.of(0, 1))
                    .build();
            AggregatedPage<Book> booksAgg = elasticsearchTemplate.queryForPage(build, Book.class);
            Aggregations aggregations = booksAgg.getAggregations();
            Terms terms = (Terms)aggregations.asMap().get("mainType");
            List<? extends Terms.Bucket> buckets = terms.getBuckets();
    //      取出桶内的数据
            for(Terms.Bucket bucket :buckets){
                String mainType = bucket.getKeyAsString();
                System.out.println("mainType是:"+mainType+" 总数量是:"+bucket.getDocCount());
                Aggregations subAgg = bucket.getAggregations();
                Terms subTerms = (Terms)subAgg.asMap().get("subType");
                List<? extends Terms.Bucket> subBbuckets = subTerms.getBuckets();
    //            取出子桶中的内容
                for (Terms.Bucket bucket1 : subBbuckets){
                    String subType = bucket1.getKeyAsString();
                    long subCount = bucket1.getDocCount();
                    System.out.println("=======对应的子级聚合的子类是:"+subType+" 子级数量是:"+subCount);
                }
            }
        }

    向es es_book_index 索引中插入500条数据,然后再统计,最后可以得到相应的统计结果:

    mainType是:法律学mainType的总数量是:128
    =======对应的子级聚合的子类是:民法 子级数量是:45
    =======对应的子级聚合的子类是:刑法 子级数量是:43
    =======对应的子级聚合的子类是:商法 子级数量是:40
    mainType是:编程学mainType的总数量是:128
    =======对应的子级聚合的子类是:python 子级数量是:42
    =======对应的子级聚合的子类是:Java 子级数量是:31
    =======对应的子级聚合的子类是:c++ 子级数量是:29
    =======对应的子级聚合的子类是:go 子级数量是:26
    mainType是:文学mainType的总数量是:127
    =======对应的子级聚合的子类是:小说 子级数量是:40
    =======对应的子级聚合的子类是:话剧 子级数量是:37
    =======对应的子级聚合的子类是:散文 子级数量是:28
    =======对应的子级聚合的子类是:诗歌 子级数量是:22
    mainType是:数学mainType的总数量是:117
    =======对应的子级聚合的子类是:几何 子级数量是:62
    =======对应的子级聚合的子类是:代数 子级数量是:55

    三、小结

     借助elasticsearchTemplate 可以为我们提供强大的搜索统计功能,项目中我们经常以时间为横坐标,做各种增长趋势图等,这些需求我们都可以借助es的聚合查询轻松实现。后续将继续探讨es其他的强大功能。。。

    欢迎关注博主公众号,后台回复  207  可领取2021最新Java全栈视频教程

    展开全文
  • Spring boot JPA的复杂查询

    千次阅读 2019-07-10 17:47:59
    对于想要查询 A and (B or C )或者 A And B And (C or D) 在jpa里你不能直接用and和or把字段拼起来,因为他并不会帮你自动加上括号,经过一下午的努力,学到了两种方法,但是我只用了其中一种,另一种感觉emmm...
  • 1、添加 EntityManager @PersistenceContext private EntityManager ...2、hql 查询 //拼接sql String hql = findStatisHql( serverId, channel,startTime,endTime); // 查询数据 Query query = entityMa...
  • sql server 复杂查询语句

    千次阅读 2018-09-12 22:12:39
    --复杂查询 --聚合函数,例如min,max --1,最低工资 select min(sal) from emp select * from emp select ename,sal from emp where sal=(select min(sal) from emp) --sql语句执行顺序从右向左, --2,...
  • 1.QueryDsl的复杂查询方法 queryDSL复杂查询的分页和自定义排序实现
  • 数据库的复杂查询

    千次阅读 2018-08-24 23:32:25
    多表查询/跨表查询 示例:查询所有的员工姓名及其所在部门的名称 SELECT ename,dname FROM emp,dept WHERE deptId=did; 注意:为了防止出现笛卡尔积,在多表查询的时候,需要添加查询条件 问题:无法查询...
  • MybatisPlus使用queryWrapper实现复杂查询

    千次阅读 2021-07-15 00:30:46
    // mp实现负责查询操作 @Test public void testSelectQuery(){ //1,创建QueryWrapper对象 QueryWrapper<User> wrapper = new QueryWrapper<>(); // 2,通过QueryWrapper设置条件 // ge大于等于 gt...
  • SQL server 复杂查询

    千次阅读 2018-11-05 21:31:28
    通过本次实验使学生掌握数据库中表数据的各种复杂查询操作。 2.实验内容 连接查询 嵌套查询 谓词查询 3.实验环境 Windows SQL Server 实验步骤及结果 创建一个数据库,文件名为“教学” 打开“教学”数据库 ...
  • 以一个基础查询为例子 SELECT * FROM equip_info 很多时候会遇到这样 的情况,例如: SELECT * FROM rmp_equip_info WHERE is_active = 'Y' AND ( create_by = '560129864519258146' OR arrive_duty IN ...
  • SQL复杂查询语句总结

    千次阅读 多人点赞 2018-10-16 14:19:02
    delete from sc where sc.cno in(select cno from teacher te join course co on(te.tno=co.tno) where te.tname='谌燕') #17、查询各科成绩最高和最低的分:以如下形式显示:课程ID,最高分,最低分 select cno,...
  • Java多条件复杂查询

    千次阅读 2019-06-09 18:21:37
      查询是我们日常生活中最常见的功能,有的查询复杂,有的查询很简单,而我要说的查询说它复杂也不复杂,说它简单也不是很简单。下面我先给出我的UI界面和业务需求。   需求是需要根据树形的某个节点查询对应...
  • 最近自己在写项目的时候,使用到了jpa,也是各种各样复杂的操作,真是头疼的不行,所以自己也总结了一下遇到的问题和一些常见的查询方法,以免再碰到类似的查询的时候没有思路。 首先我自己做的项目一般都是...
  • MongoTemplate数据库复杂查询

    千次阅读 2018-10-28 19:52:09
    一、模糊查找 Pattern pattern=Pattern.compile(".*"+params.get("name")+".*",Pattern.CASE_INSENSITIVE);...query.addCriteria(new Criteria(new Criteria("...
  • SQL复杂查询

    万次阅读 2017-03-28 14:34:49
    连接查询是关系型数据库中的主要查询,包括等值连接查询、自然连接查询、非等值连接查询、自身连接查询、外连接查询和复合条件连接查询等。1、等值与非等值连接查询一般格式 [表名1.]<列名1> <比较运算符> [表名2.]...
  • SQL复杂查询(一)

    千次阅读 2017-06-16 14:30:36
    4.3 统计部门人数,此时由于要使用统计函数,而以上的查询无法再直接出现统计函数,所以使用子查询完成 SELECT e .empno ,e .ename ,d .dname ,d .loc ,temp .count FROM emp e,emp m,dept d ,(SELECT ...
  • MybatisPlus 分页 复杂查询

    千次阅读 2018-07-27 16:02:43
    Page page=new Page(param.getCurrent(),param.getSize()); Wrapper w= new EntityWrapper(); w.eq("trade_type",tradeType); //支付类型 w.eq("check_result",checkResult);...
  • mybatisplus多条件并列复杂查询

    千次阅读 2020-06-02 20:47:07
    在使用mybatisPlus时,有时需要一些负责的sql条件...查询条件拼接, 例如:(a and b) OR (c or d) WHERE is_deleted='n' AND (refund_sts = ? AND ( (apply_type = ? AND return_money_sts = ?) ) OR ( (change_sts =
  • 工作中,关联表查询必不可少,这里记录笔记方便复制,怎么实现多条记录一对多查询,数据模型如下 问题分析 查询结果为List<UserInfoVo>,其中UserInfoVo实体中,有private List<RoleInfoList> ...
  • SQL 的复杂查询语句,例子及解析

    千次阅读 2018-03-09 11:36:14
    select *from emp where deptno= (select deptno from emp ...这是查询出与smith同一部门的员工信息。 ----------------------------------------------------------------------------------------------------- ...
  • sql 复杂查询,一些经典查询,希望对朋友有帮助!一些经典案例
  • 发起调用的 service 部分 public IPage<ElevatorMonitorStatusVO> listByCriteria(int page, int size, String registrationCode, String administrativeRegion, String usingCorp, String installLocation, ...
  • 1.非聚合复杂查询(展示了非聚合复杂查询的常用流程) public List<EsBlog> elasticSerchTest() { //1.创建QueryBuilder(即设置查询条件)这儿创建的是组合查询(也叫多条件查询),后面会介绍更多的查询方法 /...
  • 解决mongo大数据量下复杂查询的性能问题 本篇背景是我们获取应用运行时产出的日志,做展示。比如机器人运行时日志,用户问句对应意图这些信息,对于业务方是关注的, 他可以检索相关日志信息,对不正确问句意图进行...
  • 使用PostgreSQL进行复杂查询

    千次阅读 2018-10-19 09:07:59
    SQL复杂查询与视图。 数据说明 现在有一个spj数据库,其中有四个表,分别为: S P J SPJ 供应商代码表 零件表 工程项目表 供应情况表 SQL查询 创建视图 将零件表P表与供应情况SPJ表、供应商S表结合,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 801,685
精华内容 320,674
关键字:

复杂查询

友情链接: 265680729-c-basico.rar