ES-查询相关和IK分词器

最新推荐文章于 2024-10-13 22:41:20 发布
最新推荐文章于 2024-10-13 22:41:20 发布
阅读量936 收藏 3
点赞数
分类专栏： ES 文章标签： elasticsearch 数据库 filter
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A1L__/article/details/113918902
版权
本文详细介绍了Elasticsearch的查询、排序、分页、布尔查询及聚合功能。通过实例展示了如何使用match、bool、sort、from/size等进行数据检索，并探讨了不同查询条件间的逻辑关系。此外，还提到了高亮显示和聚合函数的运用，如avg、max、min和sum。同时，讨论了IK中文分词器的使用，包括ik_max_word和ik_smart的区别。
摘要由CSDN通过智能技术生成

排序查询

创建数据

PUT books/_doc/1
{
  "name":"顾老二",
  "age":30,
  "from": "gu",
  "desc": "皮肤黑、武器长、性格直",
  "tags": ["黑", "长", "直"]
}

PUT books/_doc/2
{
  "name":"大娘子",
  "age":18,
  "from":"sheng",
  "desc":"肤白貌美，娇憨可爱",
  "tags":["白", "富","美"]
}

PUT books/_doc/3
{
  "name":"龙套偏房",
  "age":22,
  "from":"gu",
  "desc":"mmp，没怎么看，不知道怎么形容",
  "tags":["造数据", "真","难"]
}


PUT books/_doc/4
{
  "name":"石头",
  "age":29,
  "from":"gu",
  "desc":"粗中有细，狐假虎威",
  "tags":["粗", "大","猛"]
}

PUT books/_doc/5
{
  "name":"魏行首",
  "age":25,
  "from":"广云台",
  "desc":"仿佛兮若轻云之蔽月,飘飘兮若流风之回雪,mmp，最后竟然没有嫁给顾老二！",
  "tags":["闭月","羞花"]
}

降序

2.1 降序：desc

想到排序，出现在脑海中的无非就是升（正）序和降（倒）序。比如我们查询顾府都有哪些人，并根据age字段按照降序，并且，我只想看nmae和age字段：

GET books/doc/_search
{
  "query": {
    "match": {
      "from": "gu"
    }
  },
  "sort": [
    {
      "age": {
        "order": "desc"
      }
    }
  ]
}

上例，在条件查询的基础上，我们又通过sort来做排序，根据age字段排序，是降序呢还是升序，由order字段控制，desc是降序。

2.2 升序：asc

那么想要升序怎么搞呢？

GET books/doc/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [  # 这是一个列表，多个排序规则，往后再添加键值对就可以了，排序规则从上往下
    {
      "age": {
        "order": "asc"
      }
    }
  ]
}

上例，想要以升序的方式排列，只需要将order值换为asc就可以了。

三 不是什么数据类型都能排序

那么，你可能会问，除了age，能不能以别的属性作为排序条件啊？来试试：

结果跟我们想象的不一样，报错了！

注意：在排序的过程中，只能使用可排序的属性进行排序。那么可以排序的属性有哪些呢？

  • 数字
  • 日期

其他的都不行！

分页查询

二 分页查询：from/size

我们来看看elasticsearch是怎么将结果分页的：

GET books/doc/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "age": {
        "order": "desc"
      }
    }
  ], 
  "from": 2,
  "size": 1
}

上例，首先以age降序排序，查询所有。并且在查询的时候，添加两个属性from和size来控制查询结果集的数据条数。

  • from：从哪开始查
  • size：返回几条结果
  • image-20210221131417107

上例中仅有一条数据，那是为啥呢？因为我们现在只有5条数据，从第4条开始查询，就只有1条符合条件，所以，就返回了1条数据。

学到这里，我们也可以看到，我们的查询条件越来越多，开始仅是简单查询，慢慢增加条件查询，增加排序，对返回结果进行限制。所以，我们可以说：对于elasticsearch来说，所有的条件都是可插拔的，彼此之间用,分割。比如说，我们在查询中，仅对返回结果进行限制：

GET lqz/doc/_search
{
  "query": {
    "match_all": {}
  },
  "from": 4,
  "size": 2
}
# 这个的结果就是查询所有然后从第五个开始选取两条，没超出限制的话

布尔查询

一 前言

布尔查询是最常用的组合查询，根据子查询的规则，只有当文档满足所有子查询条件时，elasticsearch引擎才将结果返回。布尔查询支持的子查询条件共4中：

  • must（and）
  • should（or）
  • must_not（not）
  • filter

下面我们来看看每个子查询条件都是怎么玩的。

must

现在，我们用布尔查询所有from属性为gu的数据：

GET lqz/doc/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "from": "gu"
          }
        }
      ]
    }
  }
}

上例中，我们通过在bool属性（字段）内使用must来作为查询条件，那么条件是什么呢？条件同样被match包围，就是from为gu的所有数据。
这里需要注意的是must字段对应的是个列表，也就是说可以有多个并列的查询条件，一个文档满足各个子条件后才最终返回。

结果如下：

{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 3,
    "max_score" : 0.6931472,
    "hits" : [
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "4",
        "_score" : 0.6931472,
        "_source" : {
          "name" : "石头",
          "age" : 29,
          "from" : "gu",
          "desc" : "粗中有细，狐假虎威",
          "tags" : [
            "粗",
            "大",
            "猛"
          ]
        }
      },
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "1",
        "_score" : 0.2876821,
        "_source" : {
          "name" : "顾老二",
          "age" : 30,
          "from" : "gu",
          "desc" : "皮肤黑、武器长、性格直",
          "tags" : [
            "黑",
            "长",
            "直"
          ]
        }
      },
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "3",
        "_score" : 0.2876821,
        "_source" : {
          "name" : "龙套偏房",
          "age" : 22,
          "from" : "gu",
          "desc" : "mmp，没怎么看，不知道怎么形容",
          "tags" : [
            "造数据",
            "真",
            "难"
          ]
        }
      }
    ]
  }
}

上例中，可以看到，所有from属性为gu的数据查询出来了。

那么，我们想要查询from为gu，并且age为30的数据怎么搞呢？

GET lqz/doc/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "from": "gu"
          }
        },
        {
          "match": {
            "age": 30
          }
        }
      ]
    }
  }
}

上例中，在must列表中，在增加一个age为30的条件。

结果如下：

{
  "took" : 8,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 1,
    "max_score" : 1.287682,
    "hits" : [
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "1",
        "_score" : 1.287682,
        "_source" : {
          "name" : "顾老二",
          "age" : 30,
          "from" : "gu",
          "desc" : "皮肤黑、武器长、性格直",
          "tags" : [
            "黑",
            "长",
            "直"
          ]
        }
      }
    ]
  }
}

上例，符合条件的数据被成功查询出来了。

注意：现在你可能慢慢发现一个现象，所有属性值为列表的，都可以实现多个条件并列存在

should

那么，如果要查询只要是from为gu或者tags为闭月的数据怎么搞？

GET lqz/doc/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "match": {
            "from": "gu"
          }
        },
        {
          "match": {
            "tags": "闭月"
          }
        }
      ]
    }
  }
}

上例中，或关系的不能用must的了，而是要用should，只要符合其中一个条件就返回。

结果如下：

{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 4,
    "max_score" : 0.6931472,
    "hits" : [
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "4",
        "_score" : 0.6931472,
        "_source" : {
          "name" : "石头",
          "age" : 29,
          "from" : "gu",
          "desc" : "粗中有细，狐假虎威",
          "tags" : [
            "粗",
            "大",
            "猛"
          ]
        }
      },
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "5",
        "_score" : 0.5753642,
        "_source" : {
          "name" : "魏行首",
          "age" : 25,
          "from" : "广云台",
          "desc" : "仿佛兮若轻云之蔽月,飘飘兮若流风之回雪,mmp，最后竟然没有嫁给顾老二！",
          "tags" : [
            "闭月",
            "羞花"
          ]
        }
      },
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "1",
        "_score" : 0.2876821,
        "_source" : {
          "name" : "顾老二",
          "age" : 30,
          "from" : "gu",
          "desc" : "皮肤黑、武器长、性格直",
          "tags" : [
            "黑",
            "长",
            "直"
          ]
        }
      },
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "3",
        "_score" : 0.2876821,
        "_source" : {
          "name" : "龙套偏房",
          "age" : 22,
          "from" : "gu",
          "desc" : "mmp，没怎么看，不知道怎么形容",
          "tags" : [
            "造数据",
            "真",
            "难"
          ]
        }
      }
    ]
  }
}

返回了所有符合条件的结果。

must_not

那么，如果我想要查询from既不是gu并且tags也不是可爱，还有age不是18的数据怎么办？

GET lqz/doc/_search
{
  "query": {
    "bool": {
      "must_not": [
        {
          "match": {
            "from": "gu"
          }
        },
        {
          "match": {
            "tags": "可爱"
          }
        },
        {
          "match": {
            "age": 18
          }
        }
      ]
    }
  }
}

上例中，must和should都不能使用，而是使用must_not，又在内增加了一个age为18的条件。

结果如下：

{
  "took" : 9,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 1,
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "books",
        "_type" : "doc",
        "_id" : "5",
        "_score" : 1.0,
        "_source" : {
          "name" : "魏行首",
          "age" : 25,
          "from" : "广云台",
          "desc" : "仿佛兮若轻云之蔽月,飘飘兮若流风之回雪,mmp，最后竟然没有嫁给顾老二！",
          "tags" : [
            "闭月",
            "羞花"
          ]
        }
      }
    ]
  }
}

上例中，只有魏行首这一条数据，因为只有魏行首既不是顾家的人，标签没有可爱那一项，年龄也不等于18！
这里有点需要补充，条件中age对应的18你写成整形还是字符串都没啥……

filter

那么，如果要查询from为gu，age大于25的数据怎么查？

filter需要在bool内部，并且如果是and条件，需要用must，如果使用了should，会认为是should和filter是或者的关系

GET lqz/doc/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "from": "gu"
          }
        }
      ],
      "filter": {
        "range": {
          "age": {
            "gt": 25
          }
        }
      }
    }
  }
}

这里就用到了filter条件过滤查询，过滤条件的范围用range表示，gt表示大于，大于多少呢？是25。

结果如下：

{
  "took" : 2,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 2,
    "max_score" : 0.6931472,
    "hits" : [
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "4",
        "_score" : 0.6931472,
        "_source" : {
          "name" : "石头",
          "age" : 29,
          "from" : "gu",
          "desc" : "粗中有细，狐假虎威",
          "tags" : [
            "粗",
            "大",
            "猛"
          ]
        }
      },
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "1",
        "_score" : 0.2876821,
        "_source" : {
          "name" : "顾老二",
          "age" : 30,
          "from" : "gu",
          "desc" : "皮肤黑、武器长、性格直",
          "tags" : [
            "黑",
            "长",
            "直"
          ]
        }
      }
    ]
  }
}

上例中，age大于25的条件都已经筛选出来了。

那么要查询from是gu，age大于等于30的数据呢？

GET lqz/doc/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "from": "gu"
          }
        }
      ],
      "filter": {
        "range": {
          "age": {
            "gte": 30
          }
        }
      }
    }
  }
}

上例中，大于等于用gte表示。

结果如下：

{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 1,
    "max_score" : 0.2876821,
    "hits" : [
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "1",
        "_score" : 0.2876821,
        "_source" : {
          "name" : "顾老二",
          "age" : 30,
          "from" : "gu",
          "desc" : "皮肤黑、武器长、性格直",
          "tags" : [
            "黑",
            "长",
            "直"
          ]
        }
      }
    ]
  }
}

那么，要查询age小于25的呢？

GET lqz/doc/_search
{
  "query": {
    "bool": {
      "filter": {
        "range": {
          "age": {
            "lt": 25
          }
        }
      }
    }
  }
}

上例中，小于用lt表示，结果如下：

{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 2,
    "max_score" : 0.0,
    "hits" : [
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "2",
        "_score" : 0.0,
        "_source" : {
          "name" : "大娘子",
          "age" : 18,
          "from" : "sheng",
          "desc" : "肤白貌美，娇憨可爱",
          "tags" : [
            "白",
            "富",
            "美"
          ]
        }
      },
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "3",
        "_score" : 0.0,
        "_source" : {
          "name" : "龙套偏房",
          "age" : 22,
          "from" : "gu",
          "desc" : "mmp，没怎么看，不知道怎么形容",
          "tags" : [
            "造数据",
            "真",
            "难"
          ]
        }
      }
    ]
  }
}

在查询一个age小于等于18的怎么办呢？

GET lqz/doc/_search
{
  "query": {
    "bool": {
      "filter": {
        "range": {
          "age": {
            "lte": 18
          }
        }
      }
    }
  }
}

上例中，小于等于用lte表示。结果如下：

{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 1,
    "max_score" : 0.0,
    "hits" : [
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "2",
        "_score" : 0.0,
        "_source" : {
          "name" : "大娘子",
          "age" : 18,
          "from" : "sheng",
          "desc" : "肤白貌美，娇憨可爱",
          "tags" : [
            "白",
            "富",
            "美"
          ]
        }
      }
    ]
  }
}

要查询from是gu，age在25~30之间的怎么查？

GET lqz/doc/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "from": "gu"
          }
        }
      ],
      "filter": {
        "range": {
          "age": {
            "gte": 25,
            "lte": 30
          }
        }
      }
    }
  }
}

上例中，使用lte和gte来限定范围。结果如下：

{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 2,
    "max_score" : 0.6931472,
    "hits" : [
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "4",
        "_score" : 0.6931472,
        "_source" : {
          "name" : "石头",
          "age" : 29,
          "from" : "gu",
          "desc" : "粗中有细，狐假虎威",
          "tags" : [
            "粗",
            "大",
            "猛"
          ]
        }
      },
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "1",
        "_score" : 0.2876821,
        "_source" : {
          "name" : "顾老二",
          "age" : 30,
          "from" : "gu",
          "desc" : "皮肤黑、武器长、性格直",
          "tags" : [
            "黑",
            "长",
            "直"
          ]
        }
      }
    ]
  }
}

那么，要查询from是sheng，age小于等于25的怎么查呢？其实结果，我们可能已经想到了，只有一条，因为只有盛家小六符合结果。

GET lqz/doc/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "from": "sheng"
          }
        }
      ],
      "filter": {
        "range": {
          "age": {
            "lte": 25
          }
        }
      }
    }
  }
}

结果果然不出洒家所料！

{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 1,
    "max_score" : 0.6931472,
    "hits" : [
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "2",
        "_score" : 0.6931472,
        "_source" : {
          "name" : "大娘子",
          "age" : 18,
          "from" : "sheng",
          "desc" : "肤白貌美，娇憨可爱",
          "tags" : [
            "白",
            "富",
            "美"
          ]
        }
      }
    ]
  }
}

但是，洒家手一抖，将must换为should看看会发生什么？

GET lqz/doc/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "match": {
            "from": "sheng"
          }
        }
      ],
      "filter": {
        "range": {
          "age": {
            "lte": 25
          }
        }
      }
    }
  }
}

结果如下：

{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 3,
    "max_score" : 0.6931472,
    "hits" : [
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "2",
        "_score" : 0.6931472,
        "_source" : {
          "name" : "大娘子",
          "age" : 18,
          "from" : "sheng",
          "desc" : "肤白貌美，娇憨可爱",
          "tags" : [
            "白",
            "富",
            "美"
          ]
        }
      },
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "5",
        "_score" : 0.0,
        "_source" : {
          "name" : "魏行首",
          "age" : 25,
          "from" : "广云台",
          "desc" : "仿佛兮若轻云之蔽月,飘飘兮若流风之回雪,mmp，最后竟然没有嫁给顾老二！",
          "tags" : [
            "闭月",
            "羞花"
          ]
        }
      },
      {
        "_index" : "lqz",
        "_type" : "doc",
        "_id" : "3",
        "_score" : 0.0,
        "_source" : {
          "name" : "龙套偏房",
          "age" : 22,
          "from" : "gu",
          "desc" : "mmp，没怎么看，不知道怎么形容",
          "tags" : [
            "造数据",
            "真",
            "难"
          ]
        }
      }
    ]
  }
}

结果有点出乎意料，因为龙套偏房和魏行首不属于盛家，但也被查询出来了。那你要问了，怎么肥四？小老弟！这是因为在查询过程中，优先经过filter过滤，因为should是或关系，龙套偏房和魏行首的年龄符合了filter过滤条件，也就被放行了！所以，如果在filter过滤条件中使用should的话，结果可能不会尽如人意！建议使用must代替。

注意：filter工作于bool查询内。比如我们将刚才的查询条件改一下，把filter从bool中挪出来。

GET lqz/doc/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "from": "sheng"
          }
        }
      ]
    },
    "filter": {
      "range"： {
        "age": {
          "lte": 25
        }
      }
    }
  }
}

如上例所示，我们将filter与bool平级，看查询结果：

{
  "error": {
    "root_cause": [
      {
        "type": "parsing_exception",
        "reason": "[bool] malformed query, expected [END_OBJECT] but found [FIELD_NAME]",
        "line": 12,
        "col": 5
      }
    ],
    "type": "parsing_exception",
    "reason": "[bool] malformed query, expected [END_OBJECT] but found [FIELD_NAME]",
    "line": 12,
    "col": 5
  },
  "status": 400
}

结果报错了！所以，filter工作位置很重要。

小结：

  • must：与关系，相当于关系型数据库中的and。
  • should：或关系，相当于关系型数据库中的or。
  • must_not：非关系，相当于关系型数据库中的not。
  • filter：过滤条件。
  • range：条件筛选范围。
  • gt：大于，相当于关系型数据库中的>。
  • gte：大于等于，相当于关系型数据库中的>=。
  • lt：小于，相当于关系型数据库中的<。
  • lte：小于等于，相当于关系型数据库中的<=。

查询结果 过滤：_source

在未来，一篇文档可能有很多的字段，每次查询都默认给我们返回全部，在数据量很大的时候，是的，比如我只想查姑娘的手机号，你一并给我个喜好啊、三围什么的算什么？
所以，我们对结果做一些过滤，清清白白的告诉elasticsearch

GET books/doc/_search
{
  "query": {
    "match": {
      "name":"顾老二"
    }
  }
}

GET books/doc/_search
{
  "query": {
    "match": {
      "name":"顾老二"
    }
  },
  "_source": ["name","age"]
}

image-20210221141046275

image-20210221140927221

高亮显示

如果返回的结果集中很多符合条件的结果，那怎么能一眼就能看到我们想要的那个结果呢？比如下面网站所示的那样，我们搜索elasticsearch，在结果集中，将所有elasticsearch高亮显示？

image-20210221141335318

如上图我们搜索一样。我们该怎么做呢？

GET books/doc/_search
{
  "query": {
    "match": {
      "tags": "粗"
    }
  },
  "highlight": {
  "fields": {
    "from":{},
    "tags":{}
  }
  }
}

上例中，我们使用highlight属性来实现结果高亮显示，需要的字段名称添加到fields内即可，elasticsearch会自动帮我们实现高亮。

image-20210221142113832

自定义高亮显示

但是，你可能会问，我不想用em标签， 我这么牛逼，应该用个b标签啊！好的，elasticsearch同样考虑到你很牛逼，所以，我们可以自定义标签。

GET books/doc/_search
{
  "query": {
    "match": {
      "from": "gu"
    }
  },
  "highlight": {
    "pre_tags": "<b class='key' style='color:red'>",  # 在结果之前
    "post_tags": "</b>",  # 在结果之后
    "fields": {
      "from": {}
    }
  }
}

上例中，在highlight中，pre_tags用来实现我们的自定义标签的前半部分，在这里，我们也可以为自定义的标签添加属性和样式。post_tags实现标签的后半部分，组成一个完整的标签。至于标签中的内容，则还是交给fields来完成。

image-20210221142602857

聚合函数

聚合函数大家都不陌生，elasticsearch中也没玩出新花样，所以，这一章相对简单，只需要记得：

  • avg
  • max
  • min
  • sum

以及各自的用法即可。先来看求平均。

svg

GET books/doc/_search
{
  "query": {
    "match": {
      "from": "gu"
    }
  },
  "aggs": {  # 聚合函数aggressive
    "my_avg": {  # 结果别名
      "avg": {  # 聚合方法
        "field": "age"  # 字段
      }
    }
  },
  "_source": ["name", "age"]  # 过滤
}

image-20210221143249371

max,min.sum

  "aggs": {  # 聚合函数aggressive
    "my_max": {  # 结果别名
      "max": {  # 聚合方法
        "field": "age"  # 字段
      }
    }
  },
    "aggs": {  # 聚合函数aggressive
    "my_min": {  # 结果别名
      "min": {  # 聚合方法
        "field": "age"  # 字段
      }
    }
  },
    "aggs": {  # 聚合函数aggressive
    "my_sum": {  # 结果别名
      "sum": {  # 聚合方法
        "field": "age"  # 字段
      }
    }
  },

分组查询

现在我想要查询所有人的年龄段，并且按照15~20，20~25,25~30分组，并且算出每组的平均年龄。

分析需求，首先我们应该先把分组做出来。

GET books/doc/_search
{
  "size": 0, 
  "query": {
    "match_all": {}
  },
  "aggs": {
    "age_group": {
      "range": {
        "field": "age",
        "ranges": [
          {
            "from": 15,
            "to": 20
          },
          {
            "from": 20,
            "to": 25
          },
          {
            "from": 25,
            "to": 30
          }
        ]
      }
    }
  }
}

上例中，在aggs的自定义别名age_group中，使用range来做分组，field是以age为分组，分组使用ranges来做，from和to是范围，我们根据需求做出三组。

现在我想要查询所有人的年龄段，并且按照15~20，20~25,25~30分组，并且算出每组的平均年龄。

分析需求，首先我们应该先把分组做出来。

image-20210221150503276

返回的结果中可以看到，已经拿到了三个分组。doc_count为该组内有几条数据，此次共分为三组，查询出4条内容。还有一条数据的age属性值是30，不在分组的范围内！

那么接下来，我们就要对每个小组内的数据做平均年龄处理。

GET books/doc/_search
{
  "size": 0, 
  "query": {
    "match_all": {}
  },
  "aggs": {
    "age_group": {
      "range": {
        "field": "age",
        "ranges": [
          {
            "from": 15,
            "to": 20
          },
          {
            "from": 20,
            "to": 25
          },
          {
            "from": 25,
            "to": 30
          }
        ]
      },
      "aggs": {
        "my_avg": {
          "avg": {
            "field": "age"
          }
        }
      }
    }
  }
}

上例中，在分组下面，我们使用aggs对age做平均数处理，这样就可以了。

image-20210221150538583

在结果中，我们可以清晰的看到每组的平均年龄（my_avg的value中）。

注意：聚合函数的使用，一定是先查出结果，然后对结果使用聚合函数做处理

小结：

  • avg：求平均
  • max：最大值
  • min：最小值
  • sum：求和

欢迎斧正，that’s all

IK中文分词器

#1 github下载相应版本
https://github.com/medcl/elasticsearch-analysis-ik/releases?after=v7.5.2

2 解压到es的plugin目录下

3 重启es

ik_max_word 和 ik_smart 什么区别?

ik_max_word: 会将文本做最细粒度的拆分，比如会将“中华人民共和国国歌”拆分为“中华人民共和国,中华人民,中华,华人,人民共和国,人民,人,民,共和国,共和,和,国国,国歌”，会穷尽各种 可能的组合，适合 Term Query；

ik_smart: 会做最粗粒度的拆分，比如会将“中华人民共和国国歌”拆分为“中华人民共和国,国歌”，适合 Phrase 查询。

GET _analyze
{
  "analyzer": "ik_max_word",
  "text": "上海自来水来自海上"  
}
# text字段会分词，keyword不会分词。所以在建立i、映射关系（mapping）要先想好这个字段需不需要细分

image-20210221151905758

大数据ES数据存储，查询之IK中文分词器
09-19
对于ES IK分词插件在中文检索中非常常用，本人也使用了挺久的。但知识细节一直很碎片化，一直没有做详细的整理。过一段时间用的话，也是依然各种找资料，也因此会降低开发效率。所以在有空的时候好好整理下相关资料。也希望本文对使用 ElasticSearch 和 IK分词插件的开发者有所帮助。希望能少走点弯路。 本文包括前言、IK分词介绍、分词效果对比、自定义词典使用、索引设置和字段设置（Python 创建索引并导入数据）、查询测试（Python 查询）、结论等七个部分。
elasticsearch 基于ik分词器的分词查询和模糊匹配
朝立的博客
05-05 4559
将查询的内容分解，提取。例如 文档数据库 ，就会被分词器 分解为 文档 ，数据 ，数据库等 查询返回更加有广度。类似 mysql 语法中的 like ‘%value%’此处简单梳理一下最常用的查询。查询会将分词解析出的分词。根据具体字段精确查询内容。ES查询条件 分词查询。类似于百度的分词查询。
es 全文文本分词查询
最新发布
xl-9527 的博客
10-13 495
我们可以使用分词器来查看分词的结果，默认的分词器是standard如果是其他的可以指定分词器。
ES使用ik分词器查看分词结果及自定义词汇
beihenanfei的专栏
11-09 1499
找到es的IK插件位置：打开IKAnalyzer.cfg.xml文件添加自定义扩展文件--用户可以在这里配置自己的扩展字典 -->同时，在同级目录新建my.dic文件，加入自定义词汇，例如：1号线2号线.......保存，重启ES即可生效。注意：自定义的词库只有在使用ik_smart分词才会起作用。
requirednew基于xml配置日志不回滚_Elasticsearch配置IK分词器的远程词库
weixin_39726408的博客
11-22 192
在生活中很多很多地方都涉及到了全文检索，最常见的就好比日常使用到的百度搜索等搜索引擎，也都是基于全文检索来实现的；全文检索种类较多，就好比Elasticsearch、Sorl等。 为Ealsticsearch配置词库，可以很好的解决生活中的关键字检索的匹配度，为Elasticsearch配置远程词库的话，我们就可以实现动态的添加搜索关键字进行匹配了，就好比使用百度搜索...
ElesticSearch IK中文分词使用详解
y353790060的专栏
03-20 789
一、前言对于ES IK分词插件在中文检索中非常常用，本人也使用了挺久的。但知识细节一直很碎片化，一直没有做详细的整理。过一段时间用的话，也是依然各种找资料，也因此会降低开发效率。所以在有空的时候好好整理下相关资料。也希望本文对使用 ElasticSearch 和 IK分词插件的开发者有所帮助。希望能少走点弯路。本文包括前言、IK分词介绍、分词效果对比、自定义词典使用、索引设置和字段设置（Pytho...
elasticsearch-analysis-ik 7.10.0 分词器
01-10
Elasticsearch-analysis-ik 7.10.0 分词器是 Elasticsearch 在中文环境下的得力助手，它结合了 IK 分词器的强大功能和 Elasticsearch 的灵活性，为企业级搜索提供了坚实的基石。通过合理的配置和使用，可以显著提高...
7.17.1系列Elasticsearch的elasticsearch-analysis-ik分词器
08-07
elasticsearch-analysis-ik 是一个常用的中文分词器，在 Elasticsearch 中广泛应用于中文文本的分析和搜索。下面是 elasticsearch-analysis-ik 分词器的几个主要特点： 中文分词：elasticsearch-analysis-ik 是基于...
IK分词器elasticsearch-analysis-ik-7.17.16
12-24
IK分词器以其高效、灵活和全面的特性，被广泛应用于Elasticsearch的中文处理场景。 **版本信息** IK分词器7.17.16版是截至2023年12月24日的最新稳定版本。这一版本的发布旨在提供最新的特性和性能优化，同时也解决...
elasticsearch-analysis-ik-7.4.0 ik分词器7.4.0
04-05
type: ik_max_word # 使用IK分词器的全模式 dictionary: my_dict # 自定义词典路径 ``` **依赖库** 在提供的文件列表中，我们看到有如下几个依赖库： - `httpclient-4.5.2.jar`：Apache HttpClient，用于 HTTP ...
elasticsearch-analysis-ik 7.17.16 分词器
01-10
`elasticsearch-analysis-ik`插件将IK分词器无缝地融入Elasticsearch，使得用户在使用ES时可以直接调用IK的分词能力。安装该插件后，可以在ES的索引设置中配置IK分析器，从而实现对中文文档的高效检索。 **三、...
ES分布式搜索-IK分词器
m0_63144319的博客
03-08 1392
es在创建倒排索引时需要对文档分词；在搜索时，需要对用户输入内容分词。但默认的分词规则对中文处理并不友好。语法说明：POST：请求方式/_analyze：请求路径，这里省略了，有kibana帮我们补充：分词器类型，这里是默认的standard分词器：要分词的内容由于kibana无法识别中文词汇，在没有使用IK分词器的情况下每一个中文会逐字进行识别保存查询，所以对效率和内存的耗损都有一些代价。处理中文分词，一般会使用IK分词器。安装IK分词器，参考资料问题来了，ik分词器是怎样进行分词的？
Elasticsearch使用ik分词器
知识追寻者(Inheriting the spirit of open source, Spreading technology knowledge;)
02-10 2561
分析器 什么是分词概念？分析器能使用到哪些场景？ 分词意思就是将词语进行分组切片；比如 你好啊 可能就会被分词 为 “你好” 和 “啊”； 在进行搜索时如果根据高亮匹配就会将 “你好” 或者 “啊” 所有匹配的标题内容都匹配出来； 分析器一般就是使用在搜索引擎上；比如百度搜索 mysql时间减7天 就会匹配到 mysql, 时间 ， 减 ， 7天相匹配的内容； 如下的词条经过不同的分析器会得到不同的词条： "Set the shape to semi-transparent by calling se
es ik 多字段查询_ik 分词器和ElasticSearch查询条件
weixin_39525865的博客
12-19 347
title：百度张亚勤：ABC时代来了，迎战云计算“马拉松”创建mapping的时候指定了title字段的分词器为ik，分词结果为{"tokens": [{"token": "百度","start_offset": 0,"end_offset": 2,"type": "CN_WORD","position": 0},{"token": "百","start_offset": 0,"end_offs...
查看 docker Elasticsearch 是否安装 ik分词器
CSDN_lin2018的博客
12-02 1128
Linux 系统 怎样查看 docker Elasticsearch 是否安装 ik分词器 / 怎样查看 是否安装了IK分词器
搜索引擎ES--IK分词器
李嘉图呀李嘉图的博客
05-30 7833
集成IK分词器 概要：IKAnalyzer是一个开源的，基于java语言开发的轻量级的中文分词工具包。新版本的IKAnalyzer3.0发展为面向Java的公用分词组件，独立于Lucene项目，同时提供了对Lucene的默认优化实现。 3.0特性： 1）采用了特有的“正向迭代最细粒度切分算法“，具有60万字/秒的高速处理能力。 2）采用了多子处理器分析模式，支持：英文字母（IP地址、Email、URL）、数字（日期，常用中文数量词，罗马数字，科学计数法），中文词汇（姓名、地名处理）等分词处理。
elasticsearch 使用 ik分词器
gyk163的博客
04-19 1136
elasticsearch 中文分词器 ik
ElasticSearch集成IK分词器QueryDSL查询
喜羊羊love红太狼
06-06 935
第一步：创建索引 创建索引时分词类型text的字段指定IK分词器 { "mappings":{ "log_type":{ "properties":{ "name":{ "type":"keyword" }, "age":{ "type":"integer" },
ES搜索框架--设置IK分词器
qq_51641196的博客
04-08 3644
ES的默认中文分词效果太差了，稍微长一点的词句就完全匹配不到，于是选择使用安装IK中文分词器来实现索引的分词。参考：https://blog.csdn.net/w1014074794/article/details/119762827https://www.bbsmax.com/A/6pdDqDaXzw/一、安装官网教程：https://github.com/medcl/elasticsearc...
Elasticsearch 7.12.1 版本的 ik分词器源码解析
资源摘要信息:"适用于Elasticsearch 7.12.1版本的IK分词器" 知识点详细说明： 1. Elasticsearch概述 Elasticsearch是一个开源的搜索引擎，它基于Apache Lucene构建，旨在提供一个分布式、支持多租户、实时的搜索...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值