1. Toy模板网首页
  2. > Toy博客

ElasticSearch系列 - SpringBoot整合ES：多个精确值查询 terms

7月前 作者：我一直在流浪 分类：Toy博客 阅读(54) 违法举报

这篇具有很好参考价值的文章主要介绍了ElasticSearch系列 - SpringBoot整合ES：多个精确值查询 terms。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。


ElasticSearch - SpringBoot整合ES：多个精确值查询 terms

01. ElasticSearch terms 查询支持的数据类型

在Elasticsearch中，terms查询支持多种数据类型，包括：

字符串类型：可以将多个字符串值作为数组传递给terms查询，以匹配包含任何一个指定字符串值的文档。

数值类型：可以将多个数值作为数组传递给terms查询，以匹配包含任何一个指定数值的文档。

日期类型：可以将多个日期值作为数组传递给terms查询，以匹配包含任何一个指定日期值的文档。

布尔类型：可以将多个布尔值作为数组传递给terms查询，以匹配包含任何一个指定布尔值的文档。

复杂数据类型如数组类型，对象类型也可以支持，具体可以参考term查询，term查询支持的数据类型，terms查询就会支持。区别在于 term查询用于匹配一个字段中包含指定值的文档，terms查询用于匹配一个字段中包含指定值之一的文档。

02. ElasticSearch term和 terms 查询的区别

在Elasticsearch中，term和terms查询都用于匹配一个字段中包含指定值的文档，但它们之间有一些区别。

term查询用于匹配包含完全相同值的文档，而无法匹配包含部分匹配值的文档。例如，以下查询将返回包含"red"颜色的文档：

{
  "query": {
    "term": {
      "color": "red"
    }
  }
}

但是，如果要查询包含"red"或"blue"颜色的文档，应该使用terms查询，而不是term查询。例如，以下查询将返回包含"red"或"blue"颜色中任何一个的文档：

{
  "query": {
    "terms": {
      "color": ["red", "blue"]
    }
  }
}

terms查询可以将多个值作为数组传递，以匹配包含任何一个指定值的文档，而term查询只能匹配包含单个指定值的文档。因此，如果要匹配包含多个值的文档，应该使用terms查询，而如果要匹配包含单个值的文档，应该使用term查询。

03. ElasticSearch terms 查询数值类型数据

一定要了解 term 和 terms 是包含操作，而非等值操作。 如何理解这句话呢？

在Elasticsearch中，term查询用于匹配一个字段中包含指定值的文档，terms查询用于匹配一个字段中包含指定值之一的文档。可以将多个值作为数组传递给terms查询，以匹配包含任何一个指定值的文档。

① 索引文档，构造数据：

PUT /my_index
{
  "mappings": {
    "properties": {
      "price":{
        "type": "integer"
      }
    }
  }
}

PUT /my_index/_doc/1
{
  "price":10
}

PUT /my_index/_doc/2
{
  "price":20
}

PUT /my_index/_doc/3
{
  "price":30
}

② 查询 price 包含 "10"或"20"的文档，可以使用以下查询：

GET /my_index/_search
{
  "query": {
    "terms": {
      "price": [
        "10",
        "20"
      ]
    }
  }
}

{
  "took" : 11,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 1.0,
        "_source" : {
          "price" : 10
        }
      },
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 1.0,
        "_source" : {
          "price" : 20
        }
      }
    ]
  }
}

04. ElasticSearch terms 查询字符串型数据

terms查询用于匹配一个字段中包含指定值之一的文档。

① 索引文档，数据构造：

PUT /my_index
{
  "mappings": {
    "properties": {
      "tag":{
        "type": "keyword"
      }
    }
  }
}

PUT /my_index/_doc/1
{
  "tag":"tag1"
}

PUT /my_index/_doc/2
{
  "tag":"tag2"
}

PUT /my_index/_doc/3
{
  "tag":"tag3"
}

② 查询 tag 字段包含 tag1 和 tag2 的文档：

GET /my_index/_search
{
  "query": {
    "terms": {
      "tag": [
        "tag1",
        "tag2"
      ]
    }
  }
}

{
  "took" : 5,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 1.0,
        "_source" : {
          "tag" : "tag1"
        }
      },
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 1.0,
        "_source" : {
          "tag" : "tag2"
        }
      }
    ]
  }
}

不要使用term 和terms 查询文本类型的数据。因为会分词，查询可能会出现意想不到的结果。

05. ElasticSearch terms 查询日期性数据

① 索引文档，构造数据：

PUT /my_index
{
  "mappings": {
    "properties": {
      "createTime":{
        "type": "date",
        "format": "yyyy-MM-dd HH:mm:ss"
      }
    }
  }
}

PUT /my_index/_doc/1
{
  "createTime":"2023-03-29 10:30:11"
}

PUT /my_index/_doc/2
{
   "createTime":"2023-03-29 10:35:11"
}

PUT /my_index/_doc/3
{
   "createTime":"2023-03-29 10:38:11"
}

② 查询 createTime 字段包含 “2023-03-29 10:30:11” 或 “2023-03-29 10:38:11” 的文档：

{
  "took" : 672,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 1.0,
        "_source" : {
          "createTime" : "2023-03-29 10:30:11"
        }
      },
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "createTime" : "2023-03-29 10:38:11"
        }
      }
    ]
  }
}

06. ElasticSearch terms 查询布尔型数据

① 索引文档，构造数据：

PUT /my_index
{
  "mappings": {
    "properties": {
      "flag":{
        "type": "boolean"
      }
    }
  }
}

PUT /my_index/_doc/1
{
  "flag":true
}

PUT /my_index/_doc/2
{
  "flag":true
}

PUT /my_index/_doc/3
{
  "flag":false
}

② 查询 flag 字段包含 true 或 false 的文档：

GET /my_index/_search
{
  "query": {
    "terms": {
      "flag": [
        "true",
        "false"
      ]
    }
  }
}

{
  "took" : 30,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 3,
      "relation" : "eq"
    },
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 1.0,
        "_source" : {
          "flag" : true
        }
      },
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 1.0,
        "_source" : {
          "flag" : true
        }
      },
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "flag" : false
        }
      }
    ]
  }
}

07. ElasticSearch terms 查询数组类型数据

terms查询可以用于匹配一个字段中包含指定值之一的文档。对于数组类型的字段，可以将多个值作为数组传递给terms查询，以匹配包含任何一个指定值的文档。

① 索引文档，构造数据：

PUT /my_index
{
  "mappings": {
    "properties": {
      "tags":{
        "type": "keyword"
      }
    }
  }
}

PUT /my_index/_doc/1
{
  "tags":["tag1"]
}

PUT /my_index/_doc/2
{
  "tags":["tag2"]
}

PUT /my_index/_doc/3
{
  "tags":["tag1","tag2"]
}

PUT /my_index/_doc/4
{
  "tags":["tag1","tag2","tag3"]
}

② 要查询 tags 字段包含"tag1"或"tag2"的文档，可以使用以下查询：

GET /my_index/_search
{
  "query": {
    "terms": {
      "tags": [
        "tag1",
        "tag2"
      ]
    }
  }
}

{
  "took" : 4,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 4,
      "relation" : "eq"
    },
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 1.0,
        "_source" : {
          "tags" : [
            "tag1"
          ]
        }
      },
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 1.0,
        "_source" : {
          "tags" : [
            "tag2"
          ]
        }
      },
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "tags" : [
            "tag1",
            "tag2"
          ]
        }
      },
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : 1.0,
        "_source" : {
          "tags" : [
            "tag1",
            "tag2",
            "tag3"
          ]
        }
      }
    ]
  }
}

08. ElasticSearch terms 查询对象型数据

① 索引文档，构造数据：

PUT /my_index
{
  "mappings": {
    "properties": {
      "person": {
        "type": "object",
        "properties": {
          "name": {
            "type": "keyword"
          },
          "age": {
            "type": "integer"
          },
          "address": {
            "type": "keyword"
          }
        }
      }
    }
  }
}

PUT /my_index/_doc/1
{
  "person": {
    "name": "John",
    "age": 30,
    "address": "123 Main St"
  }
}

PUT /my_index/_doc/2
{
  "person": {
    "name": "Alex",
    "age": 20,
    "address": "123 Main St"
  }
}

PUT /my_index/_doc/3
{
  "person": {
    "name": "Smith",
    "age": 10,
    "address": "123 Main St"
  }
}

② 查询 person.name 字段包含 Alex 或者 Smith 的文档：文章来源地址https://www.toymoban.com/news/detail-576453.html

{
  "took" : 2,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 1.0,
        "_source" : {
          "person" : {
            "name" : "Alex",
            "age" : 20,
            "address" : "123 Main St"
          }
        }
      },
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "person" : {
            "name" : "Smith",
            "age" : 10,
            "address" : "123 Main St"
          }
        }
      }
    ]
  }
}

09. SpringBoot 整合ES实现terms查询

GET /my_index/_search
{
  "query": {
    "terms": {
      "price": [
        "10",
        "20"
      ]
    }
  }
}

@Slf4j
@Service
public class ElasticSearchImpl {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    public void searchUser() throws IOException {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        // terms查询
        List<Integer> prices = Arrays.asList(10,20);
        // 查询所有price字段包含10或者20的文档
        TermsQueryBuilder termsQueryBuilder = new TermsQueryBuilder("price",prices);
        searchSourceBuilder.query(termsQueryBuilder);

        SearchRequest searchRequest = new SearchRequest(new String[]{"my_index"},searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println(searchResponse);
    }
}

10. SpringBoot 整合ES实现terms查询

GET /my_index/_search
{
  "query": {
    "terms": {
      "tags": ["tag1","tag2"]
    }
  }
}

@Slf4j
@Service
public class ElasticSearchImpl {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    public void searchUser() throws IOException {
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        // terms查询
        List<String> tags = Arrays.asList("tag1","tag2");
        // 查询所有tags字段包含tag1或者tag2的文档
        TermsQueryBuilder termsQueryBuilder = new TermsQueryBuilder("tags",tags);
        searchSourceBuilder.query(termsQueryBuilder);

        SearchRequest searchRequest = new SearchRequest(new String[]{"my_index"},searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println(searchResponse);
    }
}

到了这里，关于ElasticSearch系列 - SpringBoot整合ES：多个精确值查询 terms的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • ElasticSearch系列 - SpringBoot整合ES：查询字段不为空的文档 exists

    1. ElasticSearch exists 查询是什么 在某些场景下，我们希望找到某个字段不为空的文档，则可以用exists搜索。字段不为空的条件有： 值存在且不是 null； 值不是空数组； 值是数组，但不是 [null] 例如，查询在字段中至少有一个非空值的文档： 这些文档都将匹配上面的查询： ①

    2024年02月06日
    浏览(54)

  • ElasticSearch系列 - SpringBoot整合ES：查询条件 query 和过滤条件 filter 的区别

    01. Elasticsearch 查询条件和过滤条件的区别？ Elasticsearch中的查询条件和过滤条件都是用于搜索和过滤文档的条件，但它们之间有一些区别。 查询条件是用于计算文档相关度得分的条件，它会将所有符合条件的文档按照相关度得分从高到低排序，并返回前N个文档。查询条件可以

    2024年02月14日
    浏览(40)

  • ElasticSearch序列 - SpringBoot整合ES：范围查询 range

    01. ElasticSearch range查询是什么？ Elasticsearch 中的 range 查询可以用于查询某个字段在一定范围内的文档。 range 查询可同时提供包含和不包含这两种范围表达式，可供组合的选项如下： gt : 大于（greater than） lt : 小于（less than） gte : = 大于或等于（greater than or equal to） lte : = 小于

    2024年02月09日
    浏览(30)

  • ElasticSearch序列 - SpringBoot整合ES：根据指定的 ids 查询

    1. ElasticSearch 根据 ids 查询文档 ① 索引文档，构造数据 ② 查询文档 id 为 1 或者 2 的文档： 我们索引文档时，文档的id为整型，为什么查询出来的文档 id为字符串类型呢？如果我们使用字符串类型的文档id查询呢？ 可以看到仍然可以查询到匹配的文档。 在Elasticsearch中，文档

    2024年02月11日
    浏览(42)

  • ElasticSearch系列 - SpringBoot整合ES：ElasticSearch分析器

    1. ElasticSearch match 文本搜索的过程？ Elasticsearch 的 match 查询是一种基于文本匹配的查询方式，它的搜索过程如下： ① 将查询字符串分词：Elasticsearch 会将查询字符串分成一个个词项（term），并去除停用词（如“的”、“是”等常用词汇）和标点符号等无意义的字符。 ② 构建

    2023年04月18日
    浏览(106)

  • ElasticSearch系列 - SpringBoot整合ES：分析器

    1. ElasticSearch match 文本搜索的过程？ Elasticsearch 的 match 查询是一种基于文本匹配的查询方式，它的搜索过程如下： ① 将查询字符串分词：Elasticsearch 会将查询字符串分成一个个词项（term），并去除停用词（如“的”、“是”等常用词汇）和标点符号等无意义的字符。 ② 构建

    2024年02月06日
    浏览(46)

  • ElasticSearch系列 - SpringBoot整合ES：实现搜索结果排序 sort

    00. 数据准备 01. Elasticsearch 默认的排序方式是什么？ ElasticSearch 默认的排序方式是相关性排序。相关性排序是根据查询条件与文档的匹配程度来计算每个文档的相关性得分，然后按照得分从高到低进行排序。相关性排序是 ElasticSearch 中最常用的排序方式，因为它可以根据查询

    2024年02月02日
    浏览(35)
  • 【Elasticsearch】ES精确查询和范围查询，ES时间字段排序实例，ES倒排索引介绍

    【Elasticsearch】ES精确查询和范围查询，ES时间字段排序实例，ES倒排索引介绍

    termQuery matchQuery 模糊查询 multiMatchQuery 多个字段模糊查询 如果时间字段写入时用的类型是Text，可以用“时间字段.keyword”来处理 #查询前传入分页参数 #分页后拿到总记录数 把文档D对应到的映射转换为到文档ID的映射，每个都对应着一系列的文档，这些文

    2024年02月15日
    浏览(91)

  • ElasticSearch系列 - SpringBoot整合ES：映射中定义字段的数据类型及属性

    ElasticSearch - SpringBoot整合ES：映射定义字段的数据类型及属性 01. ElasticSearch 搜索结果的准确性和召回率是什么？ 在Elasticsearch中，搜索结果的准确性和召回率是非常重要的指标，它们反映了搜索引擎的性能和效果。以下是这两个指标的定义和解释： 准确性：搜索结果的准确性

    2024年02月08日
    浏览(35)

  • ElasticSearch系列 - SpringBoot整合ES：restHighLevelClient.count(countRequest, RequestOptions.DEFAULT)

    restHighLevelClient.count(countRequest, RequestOptions.DEFAULT) 是 Elasticsearch Java High Level REST Client 中用于执行计数请求的方法。 具体来说，它接受两个参数： countRequest：一个 CountRequest 对象，表示计数请求的参数，包括要计数的索引、查询条件等。 RequestOptions.DEFAULT：一个 RequestOptions 对象

    2024年02月08日
    浏览(43)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包