Elasticsearch-DSL查询-RestClient查询-数据聚合 --学习笔记

于 2024-07-22 18:00:00 发布
阅读量538 收藏 21
点赞数 11
分类专栏： JavaWeb学习笔记 文章标签： elasticsearch 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71386740/article/details/140008742
版权

DSL查询

lasticsearch的查询可以分为两大类：

  • 叶子查询（Leaf query clauses）：一般是在特定的字段里查询特定值，属于简单查询，很少单独使用。

  • 复合查询（Compound query clauses）：以逻辑方式组合多个叶子查询或者更改叶子查询的行为方式。

叶子查询

常见的叶子查询类型：

  • 全文检索查询（Full Text Queries）：利用分词器对用户输入搜索条件先分词，得到词条，然后再利用倒排索引搜索词条。例如：

    • match：这是最常用的查询之一，用于执行全文搜索，包括模糊匹配和短语或邻近词组查询。

      GET /{索引库名}/_search
{
  "query": {
    "match": {
      "字段名": "搜索条件"
    }
  }
}

    • multi_match：与match区别在于可以同时对多个字段搜索，而且多个字段都要满足。

      GET /{索引库名}/_search
{
  "query": {
    "multi_match": {
      "query": "搜索条件",
      "fields": ["字段1", "字段2"]
    }
  }
}

  • 精确查询（Term-level queries）：不对用户输入搜索条件分词，根据字段内容精确值匹配。但只能查找keyword、数值、日期、boolean类型的字段。例如：

    • ids：根据文档ID获取文档。

      GET /{索引库名}/_search
{
  "query": {
    "ids": {
      "values": ["1", "2", "3"] 
    }
  }
}

    • term：对于精确值查询，Term查询用于字段精确值匹配。

      GET /{索引库名}/_search
{
  "query": {
    "term": {
      "字段名": {
        "value": "搜索条件"
      }
    }
  }
}

    • range：范围查询，用于找到字段值位于指定区间内的文档。

      GET /{索引库名}/_search
{
  "query": {
    "range": {
      "字段名": {
        "gte": {最小值},
        "lte": {最大值}
      }
    }
  }
}

  • 地理坐标查询：用于搜索地理位置，搜索方式很多，例如：

    • geo_bounding_box：按矩形搜索

    • geo_distance：按点和半径搜索

  • ...略

复合查询

  • 第一类：基于逻辑运算组合叶子查询，实现组合条件，例如

    • bool

  • 第二类：基于某种算法修改查询时的文档相关性算分，从而改变文档排名。例如：

    • function_score

    • dis_max

当我们利用match查询时，文档结果会根据与搜索词条的关联度打分（_score），返回结果时按照分值降序排列。

官方文档：Compound queries | Elasticsearch Guide [7.12] | Elastic

从elasticsearch5.1开始，采用的相关性打分算法是BM25算法，公式如下：

基于这套公式，就可以判断出某个文档与用户搜索的关键字之间的关联度，还是比较准确的。但是，在实际业务需求中，常常会有竞价排名的功能。不是相关度越高排名越靠前，而是掏的钱多的排名靠前。

要要人为控制相关性算分，就需要利用elasticsearch中的function score 查询了。

算分函数查询（Function Score Query）

function score 查询中包含四部分内容：

  • 原始查询条件：query部分，基于这个条件搜索文档，并且基于BM25算法给文档打分，原始算分（query score)

  • 过滤条件：filter部分，符合该条件的文档才会重新算分

  • 算分函数：符合filter条件的文档要根据这个函数做运算，得到的函数算分（function score），有四种函数

    • weight：函数结果是常量

    • field_value_factor：以文档中的某个字段值作为函数结果

    • random_score：以随机数作为函数结果

    • script_score：自定义算分函数算法

  • 运算模式：算分函数的结果、原始查询的相关性算分，两者之间的运算方式，包括：

    • multiply：相乘

    • replace：用function score替换query score

    • 其它，例如：sum、avg、max、min

function score的运行流程如下：

  • 1）根据原始条件查询搜索文档，并且计算相关性算分，称为原始算分（query score）

  • 2）根据过滤条件，过滤文档

  • 3）符合过滤条件的文档，基于算分函数运算，得到函数算分（function score）

  • 4）将原始算分（query score）和函数算分（function score）基于运算模式做运算，得到最终结果，作为相关性算分。

因此，其中的关键点是：

  • 过滤条件：决定哪些文档的算分被修改

  • 算分函数：决定函数算分的算法

  • 运算模式：决定最终算分结果

示例：给IPhone这个品牌的手机算分提高十倍，分析如下：

  • 过滤条件：品牌必须为IPhone

  • 算分函数：常量weight，值为10

  • 算分模式：相乘multiply

对应代码如下：

GET /hotel/_search
{
  "query": {
    "function_score": {
      "query": {  .... }, // 原始查询，可以是任意条件
      "functions": [ // 算分函数
        {
          "filter": { // 满足的条件，品牌必须是Iphone
            "term": {
              "brand": "Iphone"
            }
          },
          "weight": 10 // 算分权重为2
        }
      ],
      "boost_mode": "multipy" // 加权模式，求乘积
    }
  }
}

bool查询

bool查询，即布尔查询。就是利用逻辑运算来组合一个或多个查询子句的组合。bool查询支持的逻辑运算有：

  • must：必须匹配每个子查询，类似“与”

  • should：选择性匹配子查询，类似“或”

  • must_not：必须不匹配，不参与算分，类似“非”

  • filter：必须匹配，不参与算分

bool查询的语法如下：

GET /items/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {"name": "手机"}}
      ],
      "should": [
        {"term": {"brand": { "value": "vivo" }}},
        {"term": {"brand": { "value": "小米" }}}
      ],
      "must_not": [
        {"range": {"price": {"gte": 2500}}}
      ],
      "filter": [
        {"range": {"price": {"lte": 1000}}}
      ]
    }
  }
}

出于性能考虑，与搜索关键字无关的查询尽量采用must_not或filter逻辑运算，避免参与相关性算分。 

排序

elasticsearch默认是根据相关度算分（_score）来排序，但是也支持自定义方式对搜索结果排序。不过分词字段无法排序，能参与排序字段类型有：keyword类型、数值类型、地理坐标类型、日期类型等。

语法说明：

GET /indexName/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "排序字段": {
        "order": "排序方式asc或desc"
      }
    }
  ]
}

分页

elasticsearch 默认情况下只返回top10的数据。而如果要查询更多数据就需要修改分页参数了。

elasticsearch中通过修改from、size参数来控制要返回的分页结果：

  • from：从第几个文档开始

  • size：总共查询几个文档

类似于mysql中的limit ?, ?

语法如下：

GET /items/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0, // 分页开始的位置，默认为0
  "size": 10,  // 每页文档数量，默认10
  "sort": [
    {
      "price": {
        "order": "desc"
      }
    }
  ]
}

深度分页

elasticsearch的数据一般会采用分片存储，也就是把一个索引中的数据分成N份，存储到不同节点上。这种存储方式比较有利于数据扩展，但给分页带来了一些麻烦。

比如一个索引库中有100000条数据，分别存储到4个分片，每个分片25000条数据。现在每页查询10条，查询第99页。那么分页查询的条件如下：

GET /items/_search
{
  "from": 990, // 从第990条开始查询
  "size": 10, // 每页查询10条
  "sort": [
    {
      "price": "asc"
    }
  ]
}

从语句来分析，要查询第990~1000名的数据。

从实现思路来分析，肯定是将所有数据排序，找出前1000名，截取其中的990~1000的部分。但问题来了，我们如何才能找到所有数据中的前1000名呢？

要知道每一片的数据都不一样，第1片上的第900~1000，在另1个节点上并不一定依然是900~1000名。所以我们只能在每一个分片上都找出排名前1000的数据，然后汇总到一起，重新排序，才能找出整个索引库中真正的前1000名，此时截取990~1000的数据即可。

试想一下，假如我们现在要查询的是第999页数据呢，是不是要找第9990~10000的数据，那岂不是需要把每个分片中的前10000名数据都查询出来，汇总在一起，在内存中排序？如果查询的分页深度更深呢，需要一次检索的数据岂不是更多？

由此可知，当查询分页深度较大时，汇总数据过多，对内存和CPU会产生非常大的压力。

因此elasticsearch会禁止from+ size 超过10000的请求。

针对深度分页，elasticsearch提供了两种解决方案：

  • search after：分页时需要排序，原理是从上一次的排序值开始，查询下一页数据。官方推荐使用的方式。

  • scroll：原理将排序后的文档id形成快照，保存下来，基于快照做分页。官方已经不推荐使用。

高亮

什么是高亮显示呢？

我们在百度，京东搜索时，关键字会变成红色，比较醒目，这叫高亮显示：

观察页面源码，你会发现两件事情：

  • 高亮词条都被加了<em>标签

  • <em>标签都添加了红色样式

css样式肯定是前端实现页面的时候写好的，但是前端编写页面的时候是不知道页面要展示什么数据的，不可能给数据加标签。而服务端实现搜索功能，要是有elasticsearch做分词搜索，是知道哪些词条需要高亮的。

因此词条的高亮标签肯定是由服务端提供数据的时候已经加上的。

因此实现高亮的思路就是：

  • 用户输入搜索关键字搜索数据

  • 服务端根据搜索关键字到elasticsearch搜索，并给搜索结果中的关键字词条添加html标签

  • 前端提前给约定好的html标签添加CSS样式

事实上elasticsearch已经提供了给搜索关键字加标签的语法，无需我们自己编码。

基本语法如下：

GET /{索引库名}/_search
{
  "query": {
    "match": {
      "搜索字段": "搜索关键字"
    }
  },
  "highlight": {
    "fields": {
      "高亮字段名称": {
        "pre_tags": "<em>",
        "post_tags": "</em>"
      }
    }
  }
}

  • 搜索必须有查询条件，而且是全文检索类型的查询条件，例如match

  • 参与高亮的字段必须是text类型的字段

  • 默认情况下参与高亮的字段要与搜索字段一致，除非添加：required_field_match=false

RestClient查询

文档的查询依然使用昨天学习的 RestHighLevelClient对象，查询的基本步骤如下：

  • 1）创建request对象，这次是搜索，所以是SearchRequest

  • 2）准备请求参数，也就是查询DSL对应的JSON参数

  • 3）发起请求

  • 4）解析响应，响应结果相对复杂，需要逐层解析

叶子查询

match查询：

@Test
void testMatch() throws IOException {
    // 1.创建Request
    SearchRequest request = new SearchRequest("items");
    // 2.组织请求参数
    request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);
}


multi_match查询：

@Test
void testMultiMatch() throws IOException {
    // 1.创建Request
    SearchRequest request = new SearchRequest("items");
    // 2.组织请求参数
    request.source().query(QueryBuilders.multiMatchQuery("脱脂牛奶", "name", "category"));
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);
}

range查询：

@Test
void testRange() throws IOException {
    // 1.创建Request
    SearchRequest request = new SearchRequest("items");
    // 2.组织请求参数
    request.source().query(QueryBuilders.rangeQuery("price").gte(10000).lte(30000));
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);
}

term查询：

@Test
void testTerm() throws IOException {
    // 1.创建Request
    SearchRequest request = new SearchRequest("items");
    // 2.组织请求参数
    request.source().query(QueryBuilders.termQuery("brand", "华为"));
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);
}

复合查询

示例：

@Test
void testBool() throws IOException {
    // 1.创建Request
    SearchRequest request = new SearchRequest("items");
    // 2.组织请求参数
    // 2.1.准备bool查询
    BoolQueryBuilder bool = QueryBuilders.boolQuery();
    // 2.2.关键字搜索
    bool.must(QueryBuilders.matchQuery("name", "脱脂牛奶"));
    // 2.3.品牌过滤
    bool.filter(QueryBuilders.termQuery("brand", "德亚"));
    // 2.4.价格过滤
    bool.filter(QueryBuilders.rangeQuery("price").lte(30000));
    request.source().query(bool);
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);
}

排序和分页

示例：

@Test
void testPageAndSort() throws IOException {
    int pageNo = 1, pageSize = 5;

    // 1.创建Request
    SearchRequest request = new SearchRequest("items");
    // 2.组织请求参数
    // 2.1.搜索条件参数
    request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));
    // 2.2.排序参数
    request.source().sort("price", SortOrder.ASC);
    // 2.3.分页参数
    request.source().from((pageNo - 1) * pageSize).size(pageSize);
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);
}

高亮

示例：

@Test
void testHighlight() throws IOException {
    // 1.创建Request
    SearchRequest request = new SearchRequest("items");
    // 2.组织请求参数
    // 2.1.query条件
    request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));
    // 2.2.高亮条件
    request.source().highlighter(
            SearchSourceBuilder.highlight()
                    .field("name")
                    .preTags("<em>")
                    .postTags("</em>")
    );
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);
}

文档解析

示例：

private void handleResponse(SearchResponse response) {
    SearchHits searchHits = response.getHits();
    // 1.获取总条数
    long total = searchHits.getTotalHits().value;
    System.out.println("共搜索到" + total + "条数据");
    // 2.遍历结果数组
    SearchHit[] hits = searchHits.getHits();
    for (SearchHit hit : hits) {
        // 3.得到_source，也就是原始json文档
        String source = hit.getSourceAsString();
        // 4.反序列化
        ItemDoc item = JSONUtil.toBean(source, ItemDoc.class);
        // 5.获取高亮结果
        Map<String, HighlightField> hfs = hit.getHighlightFields();
        if (CollUtils.isNotEmpty(hfs)) {
            // 5.1.有高亮结果，获取name的高亮结果
            HighlightField hf = hfs.get("name");
            if (hf != null) {
                // 5.2.获取第一个高亮结果片段，就是商品名称的高亮值
                String hfName = hf.getFragments()[0].string();
                item.setName(hfName);
            }
        }
        System.out.println(item);
    }
}

数据聚合

聚合（aggregations）可以让我们极其方便的实现对数据的统计、分析、运算。例如：

  • 什么品牌的手机最受欢迎？

  • 这些手机的平均价格、最高价格、最低价格？

  • 这些手机每月的销售情况如何？

实现这些统计功能的比数据库的sql要方便的多，而且查询速度非常快，可以实现近实时搜索效果。

聚合常见的有三类：

  • 桶（Bucket）聚合：用来对文档做分组

    • TermAggregation：按照文档字段值分组，例如按照品牌值分组、按照国家分组

    • Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组

  • 度量（Metric）聚合：用以计算一些值，比如：最大值、最小值、平均值等

    • Avg：求平均值

    • Max：求最大值

    • Min：求最小值

    • Stats：同时求max、min、avg、sum等

  • 管道（pipeline）聚合：其它聚合的结果为基础做进一步运算

注意：参加聚合的字段必须是keyword、日期、数值、布尔类型

DSL实现聚合

Bucket聚合

例如我们要统计所有商品中共有哪些商品分类，其实就是以分类（category）字段对数据分组。category值一样的放在同一组，属于Bucket聚合中的Term聚合。

基本语法如下：

GET /items/_search
{
  "size": 0, 
  "aggs": {
    "category_agg": {
      "terms": {
        "field": "category",
        "size": 20
      }
    }
  }
}

语法说明：

  • size：设置size为0，就是每页查0条，则结果中就不包含文档，只包含聚合

  • aggs：定义聚合

    • category_agg：聚合名称，自定义，但不能重复

      • terms：聚合的类型，按分类聚合，所以用term

        • field：参与聚合的字段名称

        • size：希望返回的聚合结果的最大数量

待条件聚合

真实场景下，用户会输入搜索条件，因此聚合必须是对搜索结果聚合。那么聚合必须添加限定条件。

例如，我想知道价格高于3000元的手机品牌有哪些，该怎么统计呢？

我们需要从需求中分析出搜索查询的条件和聚合的目标：

  • 搜索查询条件：

    • 价格高于3000

    • 必须是手机

  • 聚合目标：统计的是品牌，肯定是对brand字段做term聚合

语法如下：

GET /items/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "term": {
            "category": "手机"
          }
        },
        {
          "range": {
            "price": {
              "gte": 300000
            }
          }
        }
      ]
    }
  }, 
  "size": 0, 
  "aggs": {
    "brand_agg": {
      "terms": {
        "field": "brand",
        "size": 20
      }
    }
  }
}

Metric聚合

上面我们统计了价格高于3000的手机品牌，形成了一个个桶。现在我们需要对桶内的商品做运算，获取每个品牌价格的最小值、最大值、平均值。

这就要用到Metric聚合了，例如stat聚合，就可以同时获取min、max、avg等结果。

语法如下：

GET /items/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "term": {
            "category": "手机"
          }
        },
        {
          "range": {
            "price": {
              "gte": 300000
            }
          }
        }
      ]
    }
  }, 
  "size": 0, 
  "aggs": {
    "brand_agg": {
      "terms": {
        "field": "brand",
        "size": 20
      },
      "aggs": {
        "stats_meric": {
          "stats": {
            "field": "price"
          }
        }
      }
    }
  }
}

query部分就不说了，我们重点解读聚合部分语法。

可以看到我们在brand_agg聚合的内部，我们新加了一个aggs参数。这个聚合就是brand_agg的子聚合，会对brand_agg形成的每个桶中的文档分别统计。

  • stats_meric：聚合名称

    • stats：聚合类型，stats是metric聚合的一种，统计数据的count、min、max、avg、sum

      • field：聚合字段，这里选择price，统计价格

由于stats是对brand_agg形成的每个品牌桶内文档分别做统计，因此每个品牌都会统计出自己的价格最小、最大、平均值

总结

aggs代表聚合，与query同级，此时query的作用是？

  • 限定聚合的的文档范围

聚合必须的三要素：

  • 聚合名称

  • 聚合类型

  • 聚合字段

聚合可配置属性有：

  • size：指定聚合结果数量

  • order：指定聚合结果排序方式

  • field：指定聚合字段

RestClient实现聚合

可以看到在DSL中，aggs聚合条件与query条件是同一级别，都属于查询JSON参数。因此依然是利用request.source()方法来设置。

不过聚合条件的要利用AggregationBuilders这个工具类来构造。DSL与JavaAPI的语法对比如下：

 聚合结果与搜索文档同一级别，因此需要单独获取和解析。具体解析语法如下

完整代码如下：

@Test
void testAgg() throws IOException {
    // 1.创建Request
    SearchRequest request = new SearchRequest("items");
    // 2.准备请求参数
    BoolQueryBuilder bool = QueryBuilders.boolQuery()
            .filter(QueryBuilders.termQuery("category", "手机"))
            .filter(QueryBuilders.rangeQuery("price").gte(300000));
    request.source().query(bool).size(0);
    // 3.聚合参数
    request.source().aggregation(
            AggregationBuilders.terms("brand_agg").field("brand").size(5)
    );
    // 4.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 5.解析聚合结果
    Aggregations aggregations = response.getAggregations();
    // 5.1.获取品牌聚合
    Terms brandTerms = aggregations.get("brand_agg");
    // 5.2.获取聚合中的桶
    List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
    // 5.3.遍历桶内数据
    for (Terms.Bucket bucket : buckets) {
        // 5.4.获取桶内key
        String brand = bucket.getKeyAsString();
        System.out.print("brand = " + brand);
        long count = bucket.getDocCount();
        System.out.println("; count = " + count);
    }
}

A泽予
关注
  • 11
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Elasticsearch DSL 查询
彳亍
07-18 469
DSL是 Domain Specific Language（特定领域语言）的缩写。 Elasticsearch 提供了功能丰富且灵活的查询语言，即DSL 查询。你可以用它构建出更加复杂、功能更加强大的查询语句。 先来一个简单的例子，比如，我们可以这样查询 first_name 字段包含 John 的用户。 GET /alibaba/user/_search { "query" ...
django-elasticsearch-dsl-drf：将Elasticsearch DSL与Django REST框架集成
02-05
1. **Elasticsearch DSL**：理解DSL语法，如何编写查询和聚合，以及如何处理复杂的数据结构。 2. **Django REST框架**：掌握RESTful API的设计原则，了解Django REST框架的核心组件，如序列化器、视图和路由器。 3. ...
elasticsearch 搜索
04-19 2466
1、安装 1）下载： 官方下载地址：Download Elasticsearch | Elastic 我是去历史版本里下载的 7.10.1版本 2、安装/运行 下载后，解压缩，运行bin目录的：elasticsearch.bat即可运行 运行后看到如下界面： 然后访问： localhost:9200 说明：安装成功！ （坑：之前作者安装了 但是死活访问不了，后面可能是因为安装了node.js才解决，不确定解决的方法） 额外的配置： 4.打开 conf...
Elasticsearch搜索引擎（高级篇）
李青水的博客
06-14 747
Elasticsearch搜索引擎。
Elasticsearch 的 DSL查询
专注于数据库技术分享，包含但不限于Oracle，MySQL，PostgreSQL，ElasticSearch及国产数据库等
04-21 1161
Elasticsearch 的 DSL（Domain Specific Language，领域特定语言）查询是一种使用 JSON 格式表达的查询语言，用于与 Elasticsearch 集群进行复杂的搜索交互。DSL 查询提供了丰富的查询类型、过滤条件、排序选项、分页控制、聚合功能等，使得用户能够精确地描述想要从索引中检索的数据，并获得结构化的搜索结果。
【Elasticsearch】-DSL查询（从零到起飞）
最新发布
weixin_37024341的博客
07-22 151
Elasticsearch提供了DSL ( Domain Specific Language）查询，就是以SON格式来定义查询条件DSL查询可以分为两大类:叶子查询(Leaf query clauses)：一般是在特定的字段里查询特定值，属于简单查询，很少单独使用。复合查询(Compound query clauses)︰...
Elasticsearch的 DSL查询
wudonglianga的专栏
07-10 1684
2.2 全文搜索(full-text query) 2.2.1 匹配搜索(match query) 2.3 短语搜索(match phrase query) 2.3.1 query_string 查询 2.4 多字段匹配搜索(multi match query) 2.5 词条级搜索(term-level queries) 添加数据结构 和添加数据 结构 添加数据 3.5.1 词条搜索(term query) 3.5.2 词条集合搜索(terms query) 3.5.3 范围搜索(ran
elasticsearch-analysis-ik-8.11.0
11-27
Elasticsearch Analysis IK 8.11.0 是一个专为Elasticsearch 8.11.0版本设计的中文分词插件，其主要目标是提供对中文文本的高效、精确的分词能力，以提升搜索引擎的索引质量和查询效果。这个插件分为粗粒度和细粒度...
elastic-builder:Elasticsearch查询DSL的Node.js实现
05-02
Elasticsearch兼容性elastic-builder是为5.x查询DSL elastic-builder 。 但是，该库也应可与2.x一起使用。 对于较旧版本的DSL，您可以尝试或 大部分情况下， elastic-builder也与elasticsearch 6.0（alpha）兼容。 ...
elasticsearch-analysis-ik-8.1.3.zip
04-11
通过SpringData-elasticsearch，开发者可以利用Spring的注解驱动和模板方法，轻松地在Java应用中实现Elasticsearch的操作，如索引管理、文档操作和查询构建。 **总结** Elasticsearch-analysis-ik插件是Elastic...
elasticsearch-analysis-dynamic-synonym-7.6.2
08-17
总的来说，`elasticsearch-analysis-dynamic-synonym-7.6.2`插件是ES7.6.2版本中实现动态同义词功能的重要工具，它通过高效的数据处理和灵活的API，让同义词管理变得更加便捷，极大地提升了ES在实际业务中的应用效果...
Elasticsearch DSL 查询语句
彳亍
07-28 4486
在 ES 中，提供了十分丰富的DSL 查询。 DSL 查询使用 JSON 格式的请求体与 ES 交互，可以实现各种各样的查询需求。
Elasticsearch 查询DSL
做Java整整10年，目前是教别人写代码，嘿嘿
12-24 853
在Elasticsearch中，搜索是通过使用基于JSON的查询来进行的。查询由两个子句组成
微服务11_ES：DSL/RestClient查询文档
weixin_43989347的博客
03-30 1580
微服务11_ES：DSL/RestClient查询文档一、DSL查询文档1、DSL Query的分类1.全文检索查询match查询示例：multi_match查询示例：2.精准查询term查询range查询总结3.地理坐标查询矩形范围查询 （用得少）附近查询4.复合查询1.相关性算分2.算分函数查询示例3.布尔查询1）语法示例：2）示例3）小结二.搜索结果处理2.1.排序2.1.1.普通字段排序2.1.2.地理坐标排序2.2.分页2.2.1.基本的分页2.2.2.深度分页问题2.2.3.小结2.3.高亮2.
Elasticsearch - DSL 查询语句
从零开始的博客
07-25 1252
ES 查询、结果处理、API使用
ElasticSearch查询DSL：从基础到高级应用
silenceallat的博客
03-27 773
本文深入讲解了ElasticSearch查询DSL（Domain Specific Language）的使用，涵盖了基本概念、高级查询技巧、最佳实践和实际案例分析。文章强调了ElasticSearch作为一个强大搜索工具的潜力，并提醒读者通过不断实践和学习，才能充分发挥其功能。
elasticsearch的dsl查询
huan的学习记录
08-16 454
测试es的dsl查询，准备数据，在插入数据的时候，如果index、type、mapping都没有,es会自动创建 一、数据的准备 curl -XPOST "http://192.168.99.1:9200/new_index/product/p1" -d' { "name":"new Mac Book" }' curl -XPOST "http://192.168.99.1:...
Elasticsearch Query DSL查询入门
weixin_33962621的博客
05-16 445
本篇为学习DSL时做的笔记，适合ES新手，大佬请略过~ Query DSL又叫查询表达式，是一种非常灵活又富有表现力的查询语言，采用JSON接口的方式实现丰富的查询，并使你的查询语句更灵活、更精确、更易读且易调试 查询与过滤 Elasticsearch（以下简称ES）中的数据检索分为两种情况：查询和过滤。 Query查询会对检索结果进行评分，注重的点是匹配程度，例如检索“运维咖啡吧”与文档的标...
python elasticsearch-dsl查询优化
06-09
针对 Elasticsearch DSL 查询的优化，可以从以下几个方面考虑： 1. 使用合适的查询类型：Elasticsearch DSL 提供了多种查询类型，如 term、match、range、bool 等，不同类型的查询适用于不同的场景。选择合适的查询...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

A泽予

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值