Elasticsearch语法（聚合）

查询语法结构

GET /{索引名}/_search
{
	"from" : 0,  // 返回搜索结果的开始位置
  	"size" : 10, // 分页大小，一次返回多少数据
  	"_source" :[ ...需要返回的字段数组... ],
	"query" : { ...query子句... },
	"aggs" : { ..aggs子句..  },
	"sort" : { ..sort子句..  }
}

{
  "took" : 5, // 查询消耗时间，单位毫秒 
  "timed_out" : false, // 查询是否超时
  "_shards" : { // 本次查询参与的ES分片信息，查询中参与分片的总数，以及这些分片成功了多少个失败了多少个
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : { // hits字段包含我们搜索匹配的结果
    "total" : { // 匹配到的文档总数
      "value" : 1, // 找到1个文档
      "relation" : "eq"
    },
    "max_score" : 1.0, // 匹配到的最大分值
    "hits" : [ 
         // 这里就是我们具体的搜索结果，是一个JSON文档数组
    ]
  }
}

Elasticsearch query查询语法

// 匹配单个字段   match  全局查询
GET /{索引名}/_search
{
  "query": {
    "match": {
      "匹配字段": "匹配内容"
    }
  }
}
// 精准匹配 / 多单个字段   
GET /{索引名}/_search
{
  "query": {
    "term": {   // 精准匹配 = sql的"="
      "某字段": "匹配值"
    },
    "terms": {  // 任意值匹配 = sql in 语句 
      "shop_id": [123,100,300]
    }
  }
}
//范围查询 range
GET /order_v2/_search
{
  "query": {
    "range": {
      "shop_id": {
        "gte": 10, // gt大于  gte大于等于
        "lte": 200 // lt小于  lte小于等于
      }
    }
  }
}
// bool查询
GET /{索引名}/_search
{
  "query": {
    "bool": { // bool查询
      "must": [], // must条件，类似SQL中的and, 代表必须匹配条件
      "must_not": [], // must_not条件，跟must相反，必须不匹配条件
      "should": [] // should条件，类似SQL中or, 代表匹配其中一个条件
    }
  }
}

Elasticsearch 全文搜索

分词器

GET /_analyze
{
  "text": "上海大学",
  "analyzer": "standard"  //默认分词器 英文友好 中文不适
}
GET /_analyze
{
  "text": "红烧牛肉面",
  "analyzer": "smartcn"   //官方推荐中文分词插件
}

ik分词器 自定义扩展词库
下载地址，保持es版本一致https://github.com/medcl/elasticsearch-analysis-ik/releases

两种分词器
ik_smart - 粗粒度的分词
ik_max_word - 会尽可能的枚举可能的关键词，就是分词比较细致一些，会分解出更多的关键词
"text": "上海人民广场麻辣烫",
"analyzer": "ik_max_word"
结果：【"上海人"，"上海"，"人民"，"广场"，"麻辣烫"，"麻辣"，"烫"】
-----------------------------------------------------
"text": "上海人民广场麻辣烫",
"analyzer": "ik_smart"
结果：【"上海"，"人民"，"广场"，"麻辣烫"，"麻辣"】

Elasticsearch sort排序子句

GET /order_v2/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "order_no": {  // 字段倒叙
        "order": "desc"
      }
    },
    {
      "shop_id": {   //与上面的字段值相等 就正序
        "order": "asc"
      }
    }
  ]
}

Elasticsearch 聚合查询（aggs）基本概念

ES聚合查询类似SQL的GROUP by（分组，组内聚合）。
满足特定条件的文档的集合，叫做桶。

例：

GET /order/_search
{
    "size" : 0, // 设置size=0的意思就是，仅返回聚合查询结果，不返回普通query查询结果。
    "aggs" : { // 聚合查询语句的简写
        "popular_colors" : { // 给聚合查询取个名字，叫popular_colors
            "terms" : { // 聚合类型为，terms，terms是桶聚合的一种，类似SQL的group by的作用，根据字段分组，相同字段值的文档分为一组。
              "field" : "color" // terms聚合类型的参数，这里需要设置分组的字段为color，根据color分组
            }
        }
    }
}
// 上面没确定默认用count
select count(color) from order group by color

Elasticsearch 指标聚合（metrics）

ES指标聚合，就是类似SQL的统计函数.
常用的统计函数如下：

Value Count - 类似sql的count函数，统计总数
Cardinality - 类似SQL的count(DISTINCT 字段)， 统计不重复的数据总数
Avg - 求平均值
Sum - 求和
Max - 求最大值
Min - 求最小值

  "aggs": {
    "types_count": { // 聚合查询的名字，随便取个名字
      "value_count": { // 聚合类型为：value_count
        "field": "type" // 计算type这个字段值的总数
      }
    }
  }
select count(type) from sales

"aggs" : {
        "type_count" : { // 聚合查询的名字，随便取一个
            "cardinality" : { // 聚合查询类型为：cardinality 去重
                "field" : "type" // 根据type这个字段统计文档总数
            }
        }
    }

"aggs": {
    "avg_grade": { // 聚合查询名字，随便取一个名字
      "avg": { // 聚合查询类型为: avg
        "field": "grade" // 统计grade字段值的平均值
      }
    }
  }
略......

Elasticsearch 分组聚合查询(bucket)

ES常用的桶聚合如下：

Terms聚合 - 类似SQL的group by，根据字段唯一值分组
Histogram聚合（直方图） - 根据数值间隔分组，例如: 价格按100间隔分组，0、100、200、300等等
Date histogram聚合 - 根据时间间隔分组，例如：按月、按天、按小时分组
Range聚合 - 按数值范围分组，例如: 0-150一组，150-200一组，200-500一组。

terms聚合
"aggs": {
    "shop": { // 聚合查询的名字，随便取个名字
      "terms": { // 聚合类型为: terms
        "field": "shop_id" // 根据shop_id字段值，分桶
      }
    }
  }
select shop_id, count(*) from order group by shop_id

"aggs" : {
        "prices" : { // 聚合查询名字，随便取一个
            "histogram" : { // 聚合类型为：histogram
                "field" : "price", // 根据price字段分桶
                "interval" : 50 // 分桶的间隔为50，意思就是price字段值按50间隔分组
            }
        }
    }

"aggs" : {
        "sales_over_time" : { // 聚合查询名字，随便取一个
            "date_histogram" : { // 聚合类型为: date_histogram
                "field" : "date", // 根据date字段分组
                "calendar_interval" : "month", // 分组间隔：month代表每月、支持minute（每分钟）、hour（每小时）、day（每天）、week（每周）、year（每年）
                "format" : "yyyy-MM-dd" // 设置返回结果中桶key的时间格式
            }
        }
    }

 "aggs" : {
        "price_ranges" : { // 聚合查询名字，随便取一个
            "range" : { // 聚合类型为： range
                "field" : "price", // 根据price字段分桶
                "ranges" : [ // 范围配置
                    { "to" : 100.0 }, // 意思就是 price <= 100的文档归类到一个桶
                    { "from" : 100.0, "to" : 200.0 }, // price>100 and price<200的文档归类到一个桶
                    { "from" : 200.0 } // price>200的文档归类到一个桶
                ]
            }
        }
    }

Elasticsearch 聚合后排序

类似terms、histogram、date_histogram这类桶聚合都会动态生成多个桶，如果生成的桶特别多，我们如何确定这些桶的排序顺序，如何限制返回桶的数量。

ES桶聚合支持两种方式排序：
内置排序

_count - 按文档数排序。对 terms 、 histogram 、 date_histogram 有效
_term - 按词项的字符串值的字母顺序排序。只在 terms 内使用
_key - 按每个桶的键值数值排序, 仅对 histogram 和 date_histogram 有效	

"aggs" : {
        "colors" : { // 聚合查询名字，随便取一个
            "terms" : { // 聚合类型为: terms
              "field" : "color", 
              "order": { // 设置排序参数
                "_count" : "asc"  // 根据_count排序，asc升序，desc降序
              }
            }
        }
    }

按度量指标排序

GET /cars/_search
{
    "size" : 0,
    "aggs" : {
        "colors" : { // 聚合查询名字
            "terms" : { // 聚合类型: terms，先分桶
              "field" : "color", // 分桶字段为color
              "order": { // 设置排序参数
                "avg_price" : "asc"  // 根据avg_price指标聚合结果，升序排序。
              }
            },
            "aggs": { // 嵌套聚合查询，设置桶内聚合指标
                "avg_price": { // 聚合查询名字，前面排序引用的就是这个名字
                    "avg": {"field": "price"} // 计算price字段平均值
                }
            }
        }
    }
}
GET /_search
{
    "aggs" : {
        "products" : { // 聚合查询名字
            "terms" : { // 聚合类型为: terms
                "field" : "product", // 根据product字段分桶
                "size" : 5 // 限制最多返回5个桶
            }
        }
    }
}