从零学Elasticsearch系列——深入搜索（Query、Filter、Aggregation）

最新推荐文章于 2023-11-13 00:42:57 发布
最新推荐文章于 2023-11-13 00:42:57 发布
阅读量6.1k 收藏 29
点赞数 2
分类专栏： 全文检索 文章标签： Elasticsearch 全文检索 Query Filter Aggregation
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31871785/article/details/86137167
版权

系列文章：

搜索方式

搜索有两种方式：一种是通过URL参数进行搜索，另一种是通过DSL(Request Body)进行搜索

DSL：Domain Specified Language，特定领域语言

使用请求体可以让你的JSON数据以一种更加可读和更加富有展现力的方式发送。

导入测试数据集

# 批量插入测试数据
POST /zpark/user/_bulk
{"index":{"_id":1}}
{"name":"zs","realname":"张三","age":18,"birthday":"2018-12-27","salary":1000.0,"address":"北京市昌平区沙阳路55号"}
{"index":{"_id":2}}
{"name":"ls","realname":"李四","age":20,"birthday":"2017-10-20","salary":5000.0,"address":"北京市朝阳区三里屯街道21号"}
{"index":{"_id":3}}
{"name":"ww","realname":"王五","age":25,"birthday":"2016-03-15","salary":4300.0,"address":"北京市海淀区中关村大街新中关商城2楼511室"}
{"index":{"_id":4}}
{"name":"zl","realname":"赵六","age":20,"birthday":"2003-04-19","salary":12300.0,"address":"北京市海淀区中关村软件园9号楼211室"}
{"index":{"_id":5}}
{"name":"tq","realname":"田七","age":35,"birthday":"2001-08-11","salary":1403.0,"address":"北京市海淀区西二旗地铁辉煌国际大厦负一楼"}

查询(Query)

1. 查看所有并按照年龄降序排列

查询所有并排序

  • URL实现

    GET /zpark/user/_search?q=*&sort=age:desc&pretty

  • DSL实现

    GET /zpark/user/_search
{
  "query":{
    "match_all":{}	# 查询所有
  },
  "sort":{
      "age":"desc"  # 按年龄倒序排列
    }
}
2. 查询第2页的用户（每页显示2条）

分页查询

  • URL实现

    GET /zpark/user/_search?q=*&sort=_id:asc&from=2&size=2

  • DSL实现

    GET /zpark/user/_search
{
  "query":{
    "match_all":{}	# 查询所有
  },
  "sort":{
      "_id":"asc"   # 按年龄倒序排列
   },
  "from":2,			# 从（nowPage-1）*pageSize检索
  "size":2   		# 查 pageSize条
}
3. 查询address在海淀区的所有用户，并高亮

基于全文检索的查询（分析检索关键词 匹配索引库 返回结果）

  • DSL实现

    GET /zpark/user/_search
{
  "query": {
    "match": {  # 注意： match查询会分词 如：海淀区 会分词为 海 | 淀 | 区
      "address":"海淀区"
    }
  },
  "highlight": {
    "fields": {		# 需要高亮的字段列表
      "address": {}   
    }
  }
}
4. 查询name是zs关键字的用户

基于Term词元查询

  • URL实现

    GET /zpark/user/_search?q=name:zs

  • DSL实现

    GET /zpark/user/_search
{
  "query":{
    "term": {
      "name": {
        "value": "zs"
      }
    }
  }
}
5. 查询年龄在20~30岁之间的用户

基于范围查询

  • DSL实现

    GET /zpark/user/_search
{
  "query": {
    "range": {
      "age": {
        "gte": 20,   # 大于等于  大于用 gt
        "lte": 30    # 小于等于  小于用 lt
      }
    }
  }
}
6. 查询真实姓名以张开头的用户

基于前缀（prefix）查询

  • DSL实现

    GET /zpark/user/_search
{
  "query": {
    "prefix": {
      "realname": {
        "value": "李"
      }
    }
  }
}
7. 查询名字已s结尾的用户

基于通配符（wildcard）的查询

  • ？ 匹配一个字符
  • * 匹配0~n个字符

  • DSL实现

    GET /zpark/user/_search
{
  "query": {
    "wildcard": {
      "name": {
        "value": "*s"
      }
    }
  }
}
8. 查询id为1，2，3的用户

基于Ids的查询

  • DSL实现

    GET /zpark/user/_search
{
  "query": {
    "ids": {
      "values": [1,2,3]
    }
  }
}
9. 模糊查询realname中包含张关键字的用户

基于Fuzzy的查询

  • DSL实现

    GET /zpark/user/_search
{
  "query": {
    "fuzzy": {
      "realname": {"value": "张"}
    }
  }
}
10. 查询age在15-30岁之间并且name必须通配z*

基于Boolean的查询（多条件查询）

  • must：查询结果必须符合该查询条件（列表）。
  • should：类似于or的查询条件。
  • must_not：查询结果必须不符合查询条件（列表）。

  • DSL实现

    GET /zpark/user/_search
{
  "query": {
    "bool": {
      "must": [	   #年龄在15~30岁之间并且必须名字通配z*
        {
          "range": {
            "age": {
              "gte": 15,
              "lte": 30
            }
          }
        },
        {
          "wildcard": {
            "name": {
              "value": "z*"
            }
          }
        }
      ]，
      "must_not": [  # 正则查询 name必须不能以s结尾
        {
          "regexp": {
            "name": ".*s"
          }
        }
      ] 
    }
  }
}

过滤器（Filter）

其实准确来说，ES中的查询操作分为2种：查询（query）和过滤（filter）。查询即是之前提到的query查询，它（查询）默认会计算每个返回文档的得分，然后根据得分排序。而过滤（filter）只会筛选出符合的文档，并不计算得分，且它可以缓存文档。所以，单从性能考虑，过滤比查询更快。

换句话说，过滤适合在大范围筛选数据，而查询则适合精确匹配数据。一般应用时，应先使用过滤操作过滤数据，然后使用查询匹配数据。

过滤器使用
GET /zpark/user/_search
{
   "query":{
      "bool": {
        "must": [
          {"match_all": {}}
        ],
        "filter": {		# 过滤年龄大于等于25岁的用户
          "range": {
            "age": {
              "gte": 25
            }
          }
        }
      }
   }
}

注意： 过滤查询运行时先执行过滤语句，后执行普通查询

过滤器的类型
1. term、terms Filter

term、terms的含义与查询时一致。term用于精确匹配、terms用于多词条匹配

GET /zpark/user/_search
{
   "query":{
      "bool": {
        "must": [
          {"match_all": {}}
        ],
        "filter": {
          "terms": {
            "name": [
              "zs",
              "ls"
            ]
          }
        }
      }
   }
}
2. ranage filter
3. exists filter

exists过滤指定字段没有值的文档

GET /zpark/user/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match_all": {}
        }
      ],
      "filter": {    # 排除salary为null的结果
        "exists": {
          "field": "salary"
        }
      }
    }
  },
  "sort": [
    {
      "_id": {
        "order": "asc"
      }
    }
  ]
}

或(相反操作)

GET /zpark/user/_search
{ 
  "query": {
    "bool": {
      "must_not": [
        {
          "exists": {
            "field": "salary"
          }
        }
      ]
    }
  }
}
4. ids filter

需要过滤出若干指定_id的文档，可使用标识符过滤器(ids)

GET /zpark/user/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "address": "昌平区"
          }
        }
      ],
      "filter": {
        "ids": {   # id 过滤器
          "values": [
            1,
            2,
            3
          ]
        }
      }
    }
  }
}
5. 其余使用方式可查阅官网

Note：

Query和Filter更详细的对比可参考：https://blog.csdn.net/laoyang360/article/details/80468757

聚合（Aggregations）

https://www.elastic.co/guide/en/elasticsearch/reference/6.x/search-aggregations.html

聚合提供了功能可以分组并统计你的数据。理解聚合最简单的方式就是可以把它粗略的看做SQL的GROUP BY操作和SQL的聚合函数。

ES中常用的聚合：

  • metric（度量）聚合：度量类型聚合主要针对的number类型的数据，需要ES做比较多的计算工作，类似于关系型数据库的组函数操作
  • bucketing（桶）聚合：划分不同的“桶”，将数据分配到不同的“桶”里。非常类似sql中的group语句的含义，类似于关系型数据库的分组操作

ES中的聚合API如下：

"aggregations" : {                  // 表示聚合操作，可以使用aggs替代
    "<aggregation_name>" : {        // 聚合名，可以是任意的字符串。用做响应的key，便于快速取得正确的响应数据。
        "<aggregation_type>" : {    // 聚合类别，就是各种类型的聚合，如min等
            <aggregation_body>      // 聚合体，不同的聚合有不同的body
        }
        [,"aggregations" : { [<sub_aggregation>]+ } ]? // 嵌套的子聚合，可以有0或多个
    }
    [,"<aggregation_name_2>" : { ... } ]* // 另外的聚合，可以有0或多个
}
度量（metric）聚合
1. Avg Aggregation

平均值查询，作用于number类型字段上。如：查询用户的平均年龄

POST /zpark/user/_search
{
  "aggs": {
    "age_avg": {
      "avg": {"field": "age"}
    }
  }
}
-------------------------------------------------------------------
{
    ......
    "aggregations": {
    "age_avg": {
      "value": 23.6
    }
  }
}

也可以先过滤，再进行统计，如：

POST /zpark/user/_search
{ "query": {
    "ids": {
      "values":[1,2,3]
    }
  }, 
  "aggs": {
    "age_avg": {
      "avg": {"field": "age"}
    }
  }
}
2. Max Aggregation

最大值查询。如：查询员工的最高工资

POST /zpark/user/_search
{
  "aggs": {
    "max_salary": {
      "max": {
        "field": "salary"
      }
    }
  }
}
3. Min Aggregation
4. Sum Aggregation
5. [Stats Aggregation](Stats Aggregation)

统计查询，一次性统计出某个字段上的常用统计值

POST /zpark/user/_search
{
  "aggs": {
    "max_salary": {
      "stats": {
        "field": "salary"
      }
    }
  }
}
--------------------------------------------
{
    ....
    "aggregations": {
    "max_salary": {
      "count": 4,
      "min": 1000,
      "max": 12300,
      "avg": 5650,
      "sum": 22600
    }
  }
}
桶（bucketing）聚合
1. Range Aggregation

自定义区间范围的聚合，我们可以自己手动地划分区间，ES会根据划分出来的区间将数据分配不同的区间上去。

如： 统计0-20岁，20-35岁，35~60岁用户人数

POST /zpark/user/_search
{
  "aggs": {
    "age_ranges": {
      "range": {
        "field": "age",
        "ranges": [
          {
            "from": 0,
            "to": 20
          },
          {
            "from": 20,
            "to": 35
          },
          {
            "from": 35,
            "to": 60
          }
        ]
      }
    }
  }
}
----------------------------------------------------------
{
    ......
    "aggregations": {
    "age_ranges": {
      "buckets": [
        {
          "key": "0.0-20.0",
          "from": 0,
          "to": 20,
          "doc_count": 1   # 区间范围的文档数量
        },
        {
          "key": "20.0-35.0",
          "from": 20,
          "to": 35,
          "doc_count": 3
        },
        {
          "key": "35.0-60.0",
          "from": 35,
          "to": 60,
          "doc_count": 1
        }
      ]
    }
  }
}
2. Terms Aggregation

自定义分组依据Term，对分组后的数据进行统计

如：根据年龄分组，统计相同年龄的用户

POST /zpark/user/_search
{
  "aggs": {
    "age_counts":{
      "terms": {
        "field": "age",
        "size": 2  // 保留2个统计结果
      }
    }
  }
}
----------------------------------------------------------
{
    ......
    "aggregations": {
    "age_counts": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 2,
      "buckets": [
        {
          "key": 20,
          "doc_count": 2
        },
        {
          "key": 18,
          "doc_count": 1
        }
      ]
    }
  }
}
3. Date Range Aggregation

时间区间聚合专门针对date类型的字段，它与Range Aggregation的主要区别是其可以使用时间运算表达式。

  • now+10y：表示从现在开始的第10年。
  • now+10M：表示从现在开始的第10个月。
  • 1990-01-10||+20y：表示从1990-01-01开始后的第20年，即2010-01-01。
  • now/y：表示在年位上做舍入运算。

如： 统计生日在2018年、2017年、2016年的用户

POST /zpark/user/_search
{
  "aggs": {
    "date_counts": {
      "date_range": {
        "field": "birthday",
        "format": "yyyy-MM-dd", 
        "ranges": [
          {
            "from": "now/y",  # 当前年的1月1日
            "to": "now"       # 当前时间
          },
          {
            "from": "now/y-1y",  # 当前年上一年的1月1日
            "to":"now/y"         # 当前年的1月1日
          },
          {
            "from": "now/y-2y",  
            "to":"now/y-1y"
          }
        ]
      }
    }
  }
}
-------------------------------------------------------------------------------
{
    .....
  "aggregations": {
    "date_counts": {
      "buckets": [
        {
          "key": "2016-01-01-2017-01-01",
          "from": 1451606400000,
          "from_as_string": "2016-01-01",
          "to": 1483228800000,
          "to_as_string": "2017-01-01",
          "doc_count": 1
        },
        {
          "key": "2017-01-01-2018-01-01",
          "from": 1483228800000,
          "from_as_string": "2017-01-01",
          "to": 1514764800000,
          "to_as_string": "2018-01-01",
          "doc_count": 1
        },
        {
          "key": "2018-01-01-2018-12-26",
          "from": 1514764800000,
          "from_as_string": "2018-01-01",
          "to": 1545847233691,
          "to_as_string": "2018-12-26",
          "doc_count": 0
        }
      ]
    }
  }
}
4. Histogram Aggregation

直方图聚合，它将某个number类型字段等分成n份，统计落在每一个区间内的记录数。它与前面介绍的Range聚合非常像，只不过Range可以任意划分区间，而Histogram做等间距划分。既然是等间距划分，那么参数里面必然有距离参数，就是interval参数。

如：根据年龄间隔（5岁）统计

POST /zpark/user/_search
{
  "aggs": {
    "histogram_age": {
      "histogram": {
        "field": "age",
        "interval": 5
      }
    }
  }
}
-------------------------------------------------------------------------------
{
    ......
    "aggregations": {
    "histogram_age": {
      "buckets": [
        {
          "key": 15,
          "doc_count": 1
        },
        {
          "key": 20,
          "doc_count": 2
        },
        {
          "key": 25,
          "doc_count": 1
        },
        {
          "key": 30,
          "doc_count": 0
        },
        {
          "key": 35,
          "doc_count": 1
        }
      ]
    }
  }
}
5. Date Histogram Aggregation

日期直方图聚合，专门对时间类型的字段做直方图聚合。这种需求是比较常用见得的，我们在统计时，通常就会按照固定的时间断（1个月或1年等）来做统计。

如：按年统计用户

POST /zpark/user/_search
{
  "aggs": {
    "date_histogram": {
      "date_histogram": {
        "field": "birthday",
        "interval": "year",
        "format": "yyyy-MM-dd"
      }
    }
  }
}
-------------------------------------------------------------------------------
{
    ......
    "aggregations": {
    "date_histogram": {
      "buckets": [
        {
          "key_as_string": "2001-01-01",
          "key": 978307200000,
          "doc_count": 1
        },
        {
          "key_as_string": "2002-01-01",
          "key": 1009843200000,
          "doc_count": 0
        },
        {
          "key_as_string": "2003-01-01",
          "key": 1041379200000,
          "doc_count": 1
        },
        {
          "key_as_string": "2004-01-01",
          "key": 1072915200000,
          "doc_count": 0
        },
        {
          "key_as_string": "2005-01-01",
          "key": 1104537600000,
          "doc_count": 0
        },
        {
          "key_as_string": "2006-01-01",
          "key": 1136073600000,
          "doc_count": 0
        },
        {
          "key_as_string": "2007-01-01",
          "key": 1167609600000,
          "doc_count": 0
        },
        {
          "key_as_string": "2008-01-01",
          "key": 1199145600000,
          "doc_count": 0
        },
        {
          "key_as_string": "2009-01-01",
          "key": 1230768000000,
          "doc_count": 0
        },
        {
          "key_as_string": "2010-01-01",
          "key": 1262304000000,
          "doc_count": 0
        },
        {
          "key_as_string": "2011-01-01",
          "key": 1293840000000,
          "doc_count": 0
        },
        {
          "key_as_string": "2012-01-01",
          "key": 1325376000000,
          "doc_count": 0
        },
        {
          "key_as_string": "2013-01-01",
          "key": 1356998400000,
          "doc_count": 0
        },
        {
          "key_as_string": "2014-01-01",
          "key": 1388534400000,
          "doc_count": 0
        },
        {
          "key_as_string": "2015-01-01",
          "key": 1420070400000,
          "doc_count": 0
        },
        {
          "key_as_string": "2016-01-01",
          "key": 1451606400000,
          "doc_count": 1
        },
        {
          "key_as_string": "2017-01-01",
          "key": 1483228800000,
          "doc_count": 1
        },
        {
          "key_as_string": "2018-01-01",
          "key": 1514764800000,
          "doc_count": 1
        }
      ]
    }
  }
}
嵌套使用

聚合操作是可以嵌套使用的。通过嵌套，可以使得metric类型的聚合操作作用在每一bucket上。我们可以使用ES的嵌套聚合操作来完成稍微复杂一点的统计功能。

如：统计每年中用户的最高工资

POST /zpark/user/_search
{
  "aggs": {
    "date_histogram": {			# bucket聚合  按照年分区
      "date_histogram": {
        "field": "birthday",
        "interval": "year",
        "format": "yyyy-MM-dd"
      },
      "aggs": {
        "salary_max": {
          "max": {				# metric聚合  求最大工资
            "field": "salary"
          }
        }
      }
    }
  }
}
--------------------------------------------------------------------------------------
{
    ......
    "aggregations": {
    "date_histogram": {
      "buckets": [
        ......
        {
          "key_as_string": "2017-01-01",
          "key": 1483228800000,
          "doc_count": 1,
          "salary_max": {
            "value": 5000
          }
        },
        {
          "key_as_string": "2018-01-01",
          "key": 1514764800000,
          "doc_count": 1,
          "salary_max": {
            "value": 1000
          }
        }
      ]
    }
  }
}
高志遠
关注
专栏目录
Elasticsearch Query条件执行顺序分析
yonggeit的博客
08-24 763
在此阶段需要注意的最重要的一点是，匹配的文档分为两个阶段。首先是一个 approximations的过程（找到近似匹配的doc），它可以有效地迭代倒排中与查询匹配的文档的超集（超集包含着不匹配的doc），是因为这些超集的迭代是通过 nextDoc / advance来操作的。但实际情况要复杂一些。如果您读了上面的求交集如何执行的描述，则会发现 nextDoc（）和 advance（target）的执行顺序是基于 cost（）决定的，而 matches（）的执行顺序是基于 matchCost（）决定的。
【面试系列】Elasticsearch 高频面试题
最新发布
在路上的专栏
06-24 1088
Elasticsearch 是一个开源的分布式搜索和分析引擎，基于 Apache Lucene 构建。它能够快速存储、搜索和分析大量数据。全文搜索：支持复杂的全文搜索功能，可以处理大规模的文本数据。日志和事件数据分析：通过 ELK（Elasticsearch, Logstash, Kibana）栈进行日志收集、存储、搜索和可视化分析。实时数据监控：实时分析和监控系统、应用和用户行为数据。分析引擎：用于业务数据分析、数据挖掘和 BI（商业智能）应用。
Mongo散记--安装&聚合（aggregation）& 查询（Query）
Java之旅
07-15 3288
mongo官网：http://www.mongodb.org/ 工作中使用到Mongo，但是没有系统的学习研究过Mongo，仅对工作过程中，在Mongo的使用过程中的一些知识点做一下记录，并随时补充，达到总结备忘的目的。 本篇主要终结记录聚合和查询。
Elasticsearch---Query查询和Filter查询
Kungreye
02-07 886
转载自： 魔豆技术分享 说明：Elasticsearch == 7.3。 一、概念 1、概念 一个查询语句究竟具有什么样的行为和得到什么结果，主要取决于它到底是 Query还是Filter。两者有很大区别，我们来看下： Query context：查询上下文，这种语句在执行时既要计算文档是否匹配，还要计算文档相对于其他文档的匹配度有多高，匹配度越高，_score 分数就越高 Filter context：过滤上下文，过滤上下文中的语句在执行时只关心文档是否和查询匹配，不会计算匹配度，也就是得分。 官方示例：
es filter Aggregations
ppwwp的专栏
11-02 521
查询balance 大于20000，小于30000的数据 GET /bank/_search { "query": { "bool": { "must": { "match_all": {} }, "filter": { "range": { "balance": { "gte": 20000, "lte": 30000 } } }
Elasticsearch系列(二)--query、filter、aggregations
qq_37813807的博客
08-04 167
本文基于ES6.4版本，我也是出于学习阶段，对学习内容做个记录，如果文中有错误，请指出。 实验数据： index：book type：novel mappings： { "mappings": { "novel": { "dynamic": "false", "properties": { ...
ElastaticSearch -- es之Filters aggregation 先过滤再聚合
一生编程，快乐编程
11-13 773
使用es时，有时我们需要先过滤后再聚合，但如果直接在query的filter中过滤，不止会影响到一个聚合，还会影响到其他的聚合结果。这时可以使用Filters aggregation。也就是在aggregations中先过滤后再聚合。比如，我们想要统计深圳市某个品牌的总销售额，以及该品牌的女款衣服的销售额。直接filter过滤款式为女，那么就无法统计总销售额了。
Elasticsearch——search data概述
qq_37107851的博客
09-02 623
搜索查询是对Elasticsearch数据流或索引中数据信息的请求。 我们可以将查询视为一个问题，以Elasticsearch理解的方式编写。根据我们的数据，我们可以使用查询获得以下问题的答案： 我的服务器上的哪些进程的响应时间超过500毫秒？ 网络上的哪些用户在上周内运行了regsvr32.exe？ 我的网站上的哪些页面包含特定的单词或短语？ 搜索由一个或多个查询组成，这些查询被组合并发送到Elasticsearch。匹配搜索查询的文档将在响应的点击或搜索结果中返回。 搜索还可能包含用于更好地处
Elastic安全分析新利器 —— Event Query Language (EQL) 介绍
热门推荐
点火三周的专栏
11-18 2万+
文章目录简化复杂的查询设计一种语言应用EQLIOC 检索时间窗口搜索管道处理事件序列进程祖系 （PROCESS ANCESTRY）函数调用阀值排序 随着网络安全攻防双方的技术不断升级，敌方活动不再单纯地用静态的 “入侵指标”(IOCs)来描述。仅仅关注IOCs会导致检测变得脆弱，而且在发现未知攻击时效果不佳，因为对手可以通过简单的修改工具包以轻松逃避基于指标的检测。相反，安全从业者需要基于恶意行为的持续检测。MITRE ATT&CK框架可以帮助从业者将其防御传统技术集中在这些恶意行为上。通过将对手的
ElasticSearch详细笔记（ 从入门到入土）
GOV_D的博客
04-18 3384
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录1.ElasticSearch概述1.1 Elasticsearch 是什么1.2 全文搜索引擎1.3 Elasticsearch And Solr2. ElasticSearch安装2.1 下载和安装2.2 可能存在的问题2.3 RESTful3. ES的基本使用3.1 数据格式3.2 分片概念3.3 索引操作（1）创建索引（2） 查看所有索引（3） 查看单个索引（4） 删除索引3.4 文档操作（1）创建文档（2） 查.
【Elasticsearch学习笔记-基础篇3】Elasticsearch 聚集（aggregation）与过滤器（filter）
weixin_43742184的博客
01-05 2500
这篇主要总结一下 es 的聚集（aggregation）与过滤器（filter），不会涉及到具体的 API 操作与示例，主要总结概念性与本人理解的内容。
【弄nèng - Elasticsearch】DSL入门篇（九）—— Global aggregation和Filter aggregation
司马缸砸缸了
11-28 308
文章目录1. Global aggregation项目推荐 Global aggregation定义搜索执行上下文中所有文档的单个bucket。此上下文由正在搜索的索引和文档类型定义，但不受搜索查询本身的影响 官网传送门 1. Global aggregation POST twitter/tweet/_search { "query" : { "match" : { ...
Elasticsearch教程(6) ES桶聚合Query DSL-Terms Aggregation
Java Spring Elasticsearch
11-28 1798
Elasticsearch 桶聚合 SQL DSL JavaAPI1 准备测试数据1.1 插入数据DSL1.2 表格展示2 Terms Aggregation（根据字段的值分组）2.1 根据dept分组，求每个部门的数量2.1.1 SQL2.1.2 DSL2.2 根据dept分组，求每个部门的数量，并排序2.2.1 SQL2.2.2 DSL2.3 对统计结果过滤，加having2.3.1 SQL2...
es-aggregations聚合分析
weixin_33725722的博客
06-19 1623
聚合分析的格式： "aggregations" : { "<aggregation_name>" : { "<aggregation_type>" : { <aggregation_body> } [,"meta" : { [<meta_data_body&g...
elasticsearch aggregations_Elasticsearch聚合的嵌套桶如何排序
weixin_39782752的博客
11-30 757
欢迎访问我的GitHubhttps://github.com/zq2599/blog_demos内容：原创文章分类汇总及配套源码，涉及Java、Docker、K8S、Devops等关于嵌套桶在elasticsearch的聚合查询中，经常对聚合的数据再次做聚合处理，例如统计每个汽车品牌下的每种颜色汽车的销售额，这时候DSL中就有了多层aggs对象的嵌套，这就是嵌套桶(此名称来自《Elast...
控制ES过滤与聚合起作用的顺序
淡定一生2333的博客
08-23 2660
先给出结论：     ES在执行的时候,不是按照代码书写的顺序来执行的,而是按照API的规则来执行的。即setQuery和addAggregation在代码中的前后顺序是不影响结果的，ES会和普通的关系型数据库一样，先进行where再进行group by。   接着介绍下各种filter的作用：     1.setQuery(或者说filter)：对搜索结果和aggregation都起作用...
Elasticsearch学习(十三)————Java聚合查询文档（Aggregations Query API）
qq_42513284的博客
07-30 594
Aggregations Query API 1. package com.qin.common.util.elasticsearch.query; import org.apache.http.HttpHost; import org.elasticsearch.action.search.SearchRequest; import org.elasticsearch.action.searc...
Mongo散记--聚合（aggregation）& 查询（Query）
weixin_33949359的博客
08-16 186
mongo官网：http://www.mongodb.org/ 工作中使用到Mongo，可是没有系统的学习研究过Mongo，仅对工作过程中，在Mongo的使用过程中的一些知识点做一下记录，并随时补充，达到总结备忘的目的。 本篇主要终结记录聚合和查询。 聚合（aggregation） Count db.view_view.count() db.vi...
elasticsearch查询term等级（query查询）
white_while的博客
01-26 4098
elasticsearch查询笔记
Elasticsearch withSort
05-31
Elasticsearch withSort parameter is used to sort the search results based on one or more fields. You can specify the sorting order as ascending or descending and also control the sorting behavior ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值