Elasticsearch 06 查询操作

最新推荐文章于 2023-04-25 13:35:06 发布

loetca

最新推荐文章于 2023-04-25 13:35:06 发布

阅读量368

点赞数

分类专栏： Elasticsearch 文章标签： elasticsearch lucene 倒排索引

本文链接：https://blog.csdn.net/adsl624153/article/details/78948395

版权

Elasticsearch 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1、查询的分类

⑴ 简单查询 ⑵ 条件查询 ⑶ 聚合查询

2、简单查询

使用GET请求方式 URL格式：

  http://ES服务地址/索引/类型/要查询的文档的id

3、条件查询

使用POST请求方式 URL格式：

  http://ES服务地址/索引/_search

⑴ 全部查询

请求JSON：

{
    "query": {
        "match_all": {}
    }
}

响应结果：

{
    "took": 4, // 响应的毫秒数
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": { // 响应的结果集
        "total": ???, // 结果集总数
        "max_score": 1,
        "hits": [ // 默认返回10条数据
            {
                "_index": "索引名",
                "_type": "类型名",
                "_id": "???",
                "_score": 1,
                "_source": {
                    "???": "???",
                    "???": "???"
                }
            },
            {
                "_index": "索引名",
                "_type": "类型名",
                "_id": "???",
                "_score": 1,
                "_source": {
                    "???": "???",
                    "???": "???"
                }
            }
        ]
    }
}

⑵ 带分页的查询

请求JSON：

{
    "query": {
        "match_all": {}
    },
    "from": 起始位置, // 从0开始
    "size": 要查询的个数
}

注意：当from + size 的值大于1万时，ES会报错：

{
  "type": "query_phase_execution_exception",
  "reason": "Result window is too large, from + size must be less than or equal to: [10000] but was [???]. See the scroll api for a more efficient way to request large data sets. This limit can be set by changing the [index.max_result_window] index level setting."
}

  简单的解决方式：
    【请求方式】
        PUT

【请求的URL】

  http://ES服务地址:端口号/索引名/_settings

【请求JSON】

{
  "index": {
    "max_result_window": 最大上限(from + size的值)
  }
}

但是当数据量特别大时，通过from + size 的效率要低于使用scroll的方式。关于这点以及scroll的使用，可以自行查询网络了解

⑶ 条件查询

请求JSON：

{
    "query": {
        "match": {
            "字段": "要查询的含有的字符串"
        }
    }
}

    Tips：
        ⑴ 默认的结果集是以_source的值进行倒序排列的
        ⑵ match关键字类似于MySQL的 LIKE “%字符串%” 模糊匹配查询

⑷ 排序

请求JSON：

{
    "query": {
        "match": {
            "条件查询字段": "匹配的字符串"
        }
    },
    "sort": [
        {
            "排序的字段": {
                "order": "desc/asc"
            }
        }
    ]
}

注意：text类型的字段不能排序

4、聚合查询

⑴ 单分组聚合【分组统计】

查询JSON：

{
    "aggs": {
        "自定义统计名称": {
            "terms": {
                "field": "要统计的字段"
            }
        }
    }
}

响应结果：

"aggregations": {
    "???": { // 自定义的统计名称
        "doc_count_error_upper_bound": 0,
        "sum_other_doc_count": 0,
        "buckets": [
            {
                "key": "???",
                "doc_count": ???
            },
            {
                "key": "???",
                "doc_count": ???
            }
        ]
    }
}

⑵ 多分组聚合【分组统计】

{
    "aggs": {
        "自定义结果名称": {
            "terms": {
                "field": "要统计的字段"
            }
        },
        "自定义结果名称": {
            "terms": {
                "field": "要统计的字段"
            }
        }
    }
}

⑶ 统计结果【求出最值】

查询JSON：

{
    "aggs": {
        "自定义结果集名称": {
            "stats": {
                "field": "要统计最值的字段"
            }
        }
    }
}

注意：要统计的字段类型需要为integer类型或date类型

响应结果：

"aggregations": {
    "???": { // 自定义的结果集名称
        "count": ???, // 参与统计的文档个数
        "min": ???, // 最小值
        "max": ???, // 最大值
        "avg": ???.??? 	, // 平均值
        "sum": ???, // 合计
        "min_as_string": "yyyy-MM-dd HH:mm:ss", // 最小日期转换为字符型【日期型才会有】
        "max_as_string": "yyyy-MM-dd HH:mm:ss",
        "avg_as_string": "yyyy-MM-dd HH:mm:ss",
        "sum_as_string": "yyyy-MM-dd HH:mm:ss"
    }

}

Tips：也可以直接查询单个想要的统计结果【min/max/avg/sum】，例如查询最大值：

{
    "aggs": {
        "自定义结果集名称": {
            "max": {
                "field": "要查询的最大值的字段"
            }
        }
    }
}

响应结果：

"aggregations": {
    "result": {
        "value": ???, // 结果
        "value_as_string": "yyyy-MM-dd HH:mm:ss" // 日期型才有
    }
}

5、高级查询

⑴ 子条件查询 ⑵ 复合条件查询

6、子条件查询

⑴ 定义

也叫叶子条件查询，它是特定字段查询所指特定值包括Query context和Filter context

⑵ Query context

在查询过程中，除了判断文档是否满足查询条件外，ES还会计算一个_score来标识匹配的程度，用于在判断目标文档和查询条件匹配的有多好（匹配度）

    查用的查询分为：
        全文本查询：针对文本类型数据
        包括：模糊匹配、成语匹配、多个字段匹配、语法查询

字段级别查询：针对结构化数据，如数字、日期等

⑶ 模糊匹配

{
    "query": {
        "match": {
            "字段名": "模糊匹配的字符串"
        }
    }
}

    注意：模糊匹配会将匹配的字符串拆开匹配，
    例如：东北，会将含有“东”和“北”的都找出来
        match关键字类似于MySQL的 LIKE “%字符串%” 模糊匹配查询

⑷ 成语匹配

{
    "query": {
        "match_phrase": {
            "匹配的字段名": "要匹配的整个字符串"
        }
    }
}

    这样查询出来的结果是含有整个要匹配的字符串的结果，而不会将匹配字符串拆开进行匹配
    match_phrase关键字类似于MySQL的 LIKE “%字符串%” 模糊匹配查询
    例如：查询“中国”，则最终查询到的结果为“中国?”、“中国”、“?中国”、“?中国?”

⑸ 多个字段匹配

{
    "query": {
        "multi_match": {
            "query": "匹配的字符串",
            "fields": ["匹配的字段1", "匹配的字段2"]
        }
    }
}

⑹ 语法查询

{
    "query": {
        "query_string": {
            "query": "匹配字符串1 OR 匹配字符串2"
        }
    }
}

查询出含有字符串1或字符串2的结果集

或

{
    "query": {
        "query_string": {
            "query": "(匹配字符串1 AND 匹配字符串2) OR 匹配字符串3",
            "fields": ["字段1", "字段2"]
        }
    }
}

查询出同时包含字符串1和字符串2或仅包含字符串3的结果集

⑺ 结构化查询(字段级别查询)

① 单个内容匹配

{
    "query": {
        "term": {
            "要匹配的字段": "精确匹配的内容"
        }
    }
}

Tips：term关键字类似于MySQL的 = “字符串” 精确匹配查询

② 多个内容查找匹配
此外还有terms关键字，它可以接收一个数组，判断字段上的值是否在这个数组当中

{
    "query": {
        "terms": {
            "要匹配的字段": [匹配内容1, 匹配内容2, 匹配内容3]
        }
    }
}

注意：term和terms都不支持text类型的字段，即term匹配text类型的字段查询不到结果

⑻ 范围查询(字段级别查询)

{
    "query": {
        "range": {
            "范围匹配的字段名": {
                "gte": ???, // 大于等于
                "lt": ??? // 小于
            }
        }
    }
}

Tips：如果范围查询的字段是date类型，则可以使用now关键字【获取当前时间】来进行范围查找

⑼ Filter Context

和Query Context不同的是，Filter Context只判断查询的结果是否满足预期（是or不是）使用bool关键字来匹配

示例：

{
    "query": {
        "bool": {
            "filter": {
                "term": {
                    "要匹配的字段": "精确匹配的内容"
                }
            }
        }
    }
}

Tips：使用filter关键字匹配结果，ES会将匹配到的结果进行缓存，以提高查询效率

7、复合条件查询

⑴ 定义

以一定的逻辑组合子条件查询

⑵ 固定分数查询

当使用诸如match这种模糊匹配查询时，ES会给每一个匹配到的结果一个score(评分)，且按照评分倒序排序。如果想固定查询到的结果的分数，则需要使用constant_score来查询

{
    "query": {
        "constant_score": {
            "filter": {
                "match": {
                    "要匹配的字段": "模糊匹配的内容"
                }
            }
        }
    }
}

这样匹配的结果的_score(分数)就都是1了

如果想改变分数【默认为1】，可以使用boost关键字

{
    "query": {
        "constant_score": {
            "filter": {
                "match": {
                    "要匹配的字段": "模糊匹配的内容"
                }
            },
            "boost": 要固定的分数
        }
    }
}

注意：固定分数，只是改变_score的值，但是并不影响结果的查询，以及结果的排序

⑶ 布尔逻辑查询

可以对要匹配的条件进行选择，是必须是的条件(must)、可选的条件(should)，还是必须不是的条件(must_not)

{
    "query": {
        "bool": {
            "must": [
                {
                    "match": {
                        "要匹配的字段": "模糊匹配的内容"
                    }
                },
                {
                    "term": {
                        "要匹配的字段": "精确匹配的内容"
                    }
                }
            ]
        }
    }
}

或

{
    "query": {
        "bool": {
            "must": [
                {
                    "term": {
                        "要匹配的字段": "精确匹配的内容"
                    }
                }
            ],
            "should": [
                {
                    "match": {
                         "要匹配的字段": "模糊匹配的内容"
                    }
                }
            ]
        }
    }
}

或

{
    "query": {
        "bool": {
            "must_not": [
                {
                    "term": {
                        "要匹配的字段": "精确匹配的内容"
                    }
                },
                {
                    "match": {
                        "要匹配的字段": "模糊匹配的内容"
                    }
                }
            ]
        }
    }
}

8、关于text和keyword

Elasticsearch在5.* 版本的时候，将string类型分为了text类型和keyword类型其中text类型的字段会被默认的standard analyzer分词器分词，并写入倒排索引中。如果有大写字母，也会对其进行转换为小写的字母而keyword类型的字段不会被分词

所以当用term查询时，查询的是完整的匹配内容，且区分大小写；而用match查询时，会将对应的字段进行分词，大小写转换，然后再匹配查询

9、附录

{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "字段1": "属性值"
          }
        },
        {
          "term": {
            "字段2": "属性值"
          }
        }
      ],
      "filter": {
        "range": {
          "范围字段": {
            "gte": 属性值,
            "lt": 属性值
          }
        }
      }
    }
  }
}