GROUP BY分组查询与SQL执行顺序

在sql中使用group by来对select的结果进行数据分组，在具体使用group by之前需要知道一些重要的规定。 GROUP BY子句可以包含任意数目的列。也就是说可以在组里再分组，为数据分组提供更细致的控制。 如果在GROUP BY子句中指定多个分组，数据将在最后指定的分

在sql中使用group by来对select的结果进行数据分组，在具体使用group by之前需要知道一些重要的规定。

• GROUP BY子句可以包含任意数目的列。也就是说可以在组里再分组，为数据分组提供更细致的控制。
• 如果在GROUP BY子句中指定多个分组，数据将在最后指定的分组上汇总。
• GROUP BY子句中列出的每个列都必须是检索列或有效的表达式（但不能是聚集函数）。如果在SELECT中使用了表达式，则必须在GROUP BY子句中指定相同的表达式。不能使用别名。
• 出了聚集计算语句外，SELECT语句中的每一列都必须在GROUP BY子句中给出。
• 如果分组列中有NULL值，则NULL将作为一个分组返回。如果有多行NULL值，它们将分为一组。
• GROUP BY子句必须在WHERE子句之后，ORDER BY之前。

过滤分组

对分组过于采用HAVING子句。HAVING子句支持所有WHERE的操作。HAVING与WHERE的区别在于WHERE是过滤行的，而HAVING是用来过滤分组。

另一种理解WHERE与HAVING的区别的方法是，WHERE在分组之前过滤，而HAVING在分组之后以每组为单位过滤。

分组与排序

一般在使用GROUP BY子句时，也应该使用ORDER BY子句。这是保证数据正确排序的唯一方法。

SQL SELECT语句的执行顺序：

1. from子句组装来自不同数据源的数据；
2. where子句基于指定的条件对记录行进行筛选；
3. group by子句将数据划分为多个分组；
4. 使用聚集函数进行计算；
5. 使用having子句筛选分组；
6. 计算所有的表达式；
7. 使用order by对结果集进行排序；
8. select 集合输出。

举个例子吧。

select 考生姓名, max(总成绩) as max总成绩
from tb_Grade
where 考生姓名 is not null
group by 考生姓名
having max(总成绩) > 600
order by max总成绩

在上面的示例中 SQL 语句的执行顺序如下：

1. 首先执行 FROM 子句, 从 tb_Grade 表组装数据源的数据
2. 执行 WHERE 子句, 筛选 tb_Grade 表中所有数据不为 NULL 的数据
3. 执行 GROUP BY 子句, 把 tb_Grade 表按 "学生姓名" 列进行分组
4. 计算 max() 聚集函数, 按 "总成绩" 求出总成绩中最大的一些数值
5. 执行 HAVING 子句, 筛选课程的总成绩大于 600 分的.
6. 执行 ORDER BY 子句, 把最后的结果按 "Max 成绩" 进行排序.

lucene的查询与排序

序

本文主要记录一下lucene的另外两个要点的api使用：查询与排序。

查询

完全匹配查询

   /**
     * 查找指定field中包含某个关键字
     * @throws IOException
     */
    @Test
    public void termQuery() throws IOException {
        String field = "title";
//        String queryStr = "in";
//        String queryStr = "Lucene in Action";
//        String queryStr = "action";
        String queryStr = "lucene";
        Term term = new Term(field,queryStr);
        Query query = new TermQuery(term);
        executeQuery(query);
    }

模糊查询

 /**
     * 查找指定字段中包含与关键字相似的文档
     * 查询用于匹配与指定项相似的项
     * 编辑距离算法，两个字符串之间相似度的一个度量方法
     * 用来决定索引文件中的项与指定目标项的相似程度.
     * 取所有相同前缀(前缀长度可以设定)的词项做编辑距离
     *
     * 编辑距离实际上是表明两个不同的字符串需要经过多少次编辑和变换才能变为对方。
     * 通常的编辑行为包括了增加一个检索项，删除一个检索项，修改一个检索项，
     * 与普通的字符串匹配函数不同，模糊搜索里的编辑距离是以索引项为单位的。
     *
     * http://www.xinxilong.com/html/?2481.html
     * @throws IOException
     */
    @Test
    public void fuzzyQuery() throws IOException {
        String field = "title";
        String queryStr = "act";// 自动在结尾添加 ~ ,即查询act~
        Term term = new Term(field,queryStr);
        int maxEdits = 1;  //编辑距离最多不能超过多少
        int prefixLength = 3; //相同的前缀长度
//        Query query = new FuzzyQuery(term,maxEdits,prefixLength);
        Query query = new FuzzyQuery(term,maxEdits);
//        Query query = new FuzzyQuery(term);
        executeQuery(query);
    }

多域查询

同一个关键词多个字段搜索

/**
     * http://my.oschina.net/MrMichael/blog/220694
     * 同一个关键词多个字段搜索
     * 用MultiFieldQueryParser类实现对同一关键词的跨域搜索
     */
    @Test
    public void multiFieldQueryCrossFields() throws ParseException, IOException {
        String[] fields = new String[]{"title","desc"};
        String queryStr = "good";
        Map<String , Float> boosts = new HashMap<String, Float>();
        //设定它们在搜索结果排序过程中的权重，权重越高，排名越靠前
        boosts.put("title", 1.0f);
        boosts.put("desc", 0.7f);
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, new StandardAnalyzer(),boosts);
        Query query = parser.parse(queryStr);
        executeQuery(query);
    }

使用多个关键字及多个field进行查询

/**
     * 使用多个关键字,及多个field进行查询
     */
    @Test
    public void multiFieldQueryMultiKeyword() throws ParseException, IOException {
        String[] queries = {"good","lucene"};
        String[] fields = {"title","desc"};
        BooleanClause.Occur[] clauses = {BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD};
        Query query = MultiFieldQueryParser.parse(queries,fields,clauses,new StandardAnalyzer());
        executeQuery(query);
    }

通配符查询

/**
     * 通配符查询
     * 星号*:代表0个或多个字母
     * 问号?:代表0个或1个字母
     */
    @Test
    public void wildcardQuery() throws IOException {
        String field = "title";
//        String queryStr = "*pute?";
        String queryStr = "act*";
        Term term = new Term(field,queryStr);
        Query query = new WildcardQuery(term);
        executeQuery(query);
    }

前缀查询

   /**
     * 前缀查询
     * 自动在关键词末尾添加*
     */
    @Test
    public void prefixQuery() throws IOException {
        String field = "title";
        String queryStr = "act"; //act*
        Term term = new Term(field,queryStr);
        Query query = new PrefixQuery(term);
        executeQuery(query);
    }

短语查询

/**
     * http://blog.csdn.net/rick_123/article/details/6708527
     * 短语查询,对关键词加引号,通过位置移动来匹配
     * slop的概念：slop是指两个项的位置之间允许的最大间隔距离
     * 例如:slop设置为1,则 quick brown fox 可以匹配 quick fox
     */
    @Test
    public void phraseQuery() throws IOException {
        Query query = new PhraseQuery.Builder()
                .setSlop(3)
                .add(new Term("title", "computer"))
                .add(new Term("title","art"))
                .build();
        executeQuery(query);
    }

跨度查询

/**
     * http://callan.iteye.com/blog/154251
     * 跨度查询,用于查询多个词的时候考虑几个词在文档中的匹配位置
     * 与phraseQuery和multiFieldQuery很相似,都是通过位置限制匹配
     * 但是spanQuery更加灵活
     *
     * SpanQuery包括以下几种：
     * SpanTermQuery：词距查询的基础，结果和TermQuery相似，只不过是增加了查询结果中单词的距离信息。
     * SpanFirstQuery：在指定距离可以找到第一个单词的查询。
     * SpanNearQuery：查询的几个语句之间保持者一定的距离。
     * SpanOrQuery：同时查询几个词句查询。
     * SpanNotQuery：从一个词距查询结果中，去除一个词距查询。
     */
    @Test
    public void spanQuery() throws IOException {
        SpanTermQuery query = new SpanTermQuery(new Term("title","art"));
        executeQuery(query);
    }

    /**
     * 第一次出现在指定位置
     * @throws IOException
     */
    @Test
    public void spanFirstQuery() throws IOException {
        SpanTermQuery query = new SpanTermQuery(new Term("title","art"));
        SpanFirstQuery spanFirstQuery =new SpanFirstQuery(query,2); //出现在第2个位置
        executeQuery(spanFirstQuery);
    }

    /**
     * SpanNearQuery中将SpanTermQuery对象作为SpanQuery对象使用的效果，与使用PharseQuery的效果非常相似。
     * 最大的区别是：在SpanNearQuery的构造函数中的第三个参数为inOrder标志，设置这个标志为true，项添加的顺序和其文档中出现的顺序相同
     */
    @Test
    public void spanNearQuery() throws IOException {
        SpanTermQuery queryScience = new SpanTermQuery(new Term("title","science"));
        SpanTermQuery queryArt = new SpanTermQuery(new Term("title","art"));
        SpanQuery[] queries = new SpanQuery[]{queryScience,queryArt};
        int slop = 2;//science 与 art两个词间隔在2以内
        boolean inOrder = false;//不需要按数组中的顺序出现在文档中
        SpanNearQuery query = new SpanNearQuery(queries,slop,inOrder);
        executeQuery(query);
    }

    @Test
    public void spanOrQuery() throws IOException {
        SpanTermQuery queryScience = new SpanTermQuery(new Term("title","science"));
        SpanTermQuery queryArt = new SpanTermQuery(new Term("title","art"));
        SpanQuery[] queries = new SpanQuery[]{queryScience,queryArt};
        int slop = 2;//science 与 art两个词间隔在2以内
        boolean inOrder = false;//不需要按数组中的顺序出现在文档中
        SpanNearQuery spanNearQuery = new SpanNearQuery(queries,slop,inOrder);

        SpanTermQuery queryComputer = new SpanTermQuery(new Term("title","lucene"));

        SpanOrQuery query = new SpanOrQuery(new SpanQuery[]{spanNearQuery,queryComputer});
        executeQuery(query);
    }

组合查询

/**
     * 组合查询
     * MUST与MUST组合表示并集
     * MUST与MUST_NOT表示包含与不包含
     * MUST_NOT与MUST_NOT组合没有意义
     * SHOULD与SHOULD组合表示或
     * SHOULD与MUST表示MUST,其中SHOULD没有任何价值
     * SHOULD与MUST_NOT相当于MUST与MUST_NOT表示包含与不包含
     */
    @Test
    public void booleanQuery() throws IOException {
        TermQuery queryComputerInTitle = new TermQuery(new Term("title","computer"));
        TermQuery queryGoodInDesc = new TermQuery(new Term("desc","good"));

        BooleanQuery booleanQuery = new BooleanQuery.Builder()
                .add(queryComputerInTitle,BooleanClause.Occur.SHOULD)
                .add(queryGoodInDesc,BooleanClause.Occur.SHOULD)
                .setMinimumNumberShouldMatch(1)
                .build();
        executeQuery(booleanQuery);
    }

排序

根据域值排序

/**
     * 按指定字段排序
     * @throws IOException
     * @throws ParseException
     */
    @Test
    public void sortByField() throws IOException, ParseException {
        //Sort using term values as encoded Integers.  Sort values are Integer and lower values are at the front.
        boolean isReverse = false;
        SortField sortField = new SortField("title", SortField.Type.STRING,isReverse);
        Query query = new TermQuery(new Term("title","lucene"));
        Sort sort = new Sort(sortField);
        executeQuery(query, sort);
    }

根据索引顺序查询

   /**
     * 按索引顺序排序
     * @throws IOException
     */
    @Test
    public void sortByIndexOrder() throws IOException {
        Query query = new TermQuery(new Term("title","lucene"));
        executeQuery(query,Sort.INDEXORDER);
    }

根据相关性排序

/**
     * 按文档的得分排序
     * @throws IOException
     */
    @Test
    public void sortByRelevance() throws IOException {
        TermQuery queryComputerInTitle = new TermQuery(new Term("title","computer"));
        TermQuery queryGoodInDesc = new TermQuery(new Term("desc","good"));

        BooleanQuery query = new BooleanQuery.Builder()
                .add(queryComputerInTitle,BooleanClause.Occur.SHOULD)
                .add(queryGoodInDesc,BooleanClause.Occur.SHOULD)
                .setMinimumNumberShouldMatch(1)
                .build();
        executeQuery(query,Sort.RELEVANCE);
    }

本工程github

参考

• 细说 lucene的fuzzyquery和wildcardquery

• lucene4下用MultiFieldQueryParser同时搜索多个field时

• 对Lucene PhraseQuery的slop的理解

• lucene的多种搜索2-SpanQuery

今天关于PDO的查询与执行和pdo查询数据的分享就到这里，希望大家有所收获，若想了解更多关于DataReader基于序数的查询与命名查询、Google BigQuery 流与执行 SQL 查询 - 定价差异、GROUP BY分组查询与SQL执行顺序、lucene的查询与排序等相关知识，可以在本站进行查询。