工作常用ES DSL查询语句（干货满满）

一、前言

?? 工作中几乎每天都需要使用到ES查询数据，需要根据自己的查询需求构造DSL查询语句来实现，本文记录并分享本人工作中常用的DSL语句以及所遇到问题的解决方案，DSL语句灵活多变，可进行多种组合，任你搭配，让我们一起往下看，希望对你有帮助。

二、DSL常用查看索引语句

2.1 查看所有索引的信息（indices?v）

GET _cat/indices
# 以表格形式展示，推荐*
GET _cat/indices?v

2.2 查看特定索引的信息（_stats）

index_name/_stats

2.3 查看索引的映射（_mapping）

index_name/_mapping

2.4 查看索引的设置（_settings）

GET index_name/_settings

2.5 查看索引的别名（aliases）

GET _cat/aliases

2.6 查看索引的文档数量（_count）

GET index_name/_count

2.7 查看索引的存储大小（_stats/store）

GET index_name/_stats/store

2.8 查看索引的字段名（_search）

GET index_name/_search?size=0

2.9 查看索引的分片信息（_cat/shards）

GET index_name/_cat/shards

2.10 查看索引的健康状态（_cluster/health）

GET _cluster/health/index_name

2.11 查看索引的索引速率（_cat/thread_pool）

GET _cat/thread_pool/index_name

2.12 查看索引的搜索速率（_cat/thread_pool/search）

GET _cat/thread_pool/search

2.13 查看索引的索引速率（_cat/thread_pool/index）

GET _cat/thread_pool/index

2.14 查看索引的删除速率（_cat/thread_pool/delete）

GET _cat/thread_pool/delete

2.15 查看索引的刷新速率（_cat/thread_pool/refresh）

GET _cat/thread_pool/refresh

2.16 查看索引的合并速率（_cat/thread_pool/merge）

GET _cat/thread_pool/merge

2.17 查看索引的查询速率（_cat/thread_pool/get）

GET _cat/thread_pool/get

2.18 查看索引的更新速率（_cat/thread_pool/update）

GET _cat/thread_pool/update

三、DSL常用查询语句

3.1 查询所有（match_all）

查询所有字段，默认显示10条数据。

GET index_name/?search
{
  "query": {
    "match_all": {
    }
  }
}

3.2 关键词全文查询（match）

GET index_name/?search
{
  "query": {
    "match": {
      "user": "YiShuoIT"
    }
  }
}

3.3 精确匹配查询（term）

GET index_name/?search
{
  "query": {
    "term": {
      "user": "YiShuoIT"
    }
  }
}

3.4 多值精确匹配查询（terms）

GET index_name/?search
{
  "query": {
    "terms": {
      "user": ["YiShuoIT", "YiShuo"]
    }
  }
}

3.5 通配符查询（wildcard）

GET index_name/?search
{
  "query": {
    "wildcard": {
      "user": "*YiShuo*"
    }
  }
}

3.6 多值通配符查询（多wildcard）

GET index_name/?search
{
  "query": {
    "bool": {
      "should": [
        {
          "wildcard": {
            "command": "curl*password*"
          }
        },
        {
          "wildcard": {
            "user": "YiShuo*"
          }
        }
      ]
    }
  }
}

3.7 字段前缀查询（prefix）

GET index_name/?search
{
   "query":{
      "prefix": {"user": "Yi"}
   }
}

3.8 多值字段前缀查询（多prefix）

GET index_name/?search
{
  "query": {
    "bool": {
      "should": [
        {
          "prefix": {
            "user": "Yi"
          }
        },
        {
          "prefix": {
            "command": "curl"
          }
        }
      ]
    }
  }
}

3.9 模糊匹配查询（fuzzy）

?? fuzziness 参数用于指定模糊匹配的容忍度。它可以是一个数字（表示编辑距离）或一个字符串（表示模糊度）。例如，“2” 表示编辑距离为 2，“auto” 表示根据术语的长度自动计算模糊度。

GET index_name/?search
{
  "query": {
    "fuzzy": {
      "user": {
        "value": "yi",
        "fuzziness": "2"
      }
    }
  }
}

3.10 正则表达式查询（regexp）

GET index_name/?search
{
  "query": {
    "regexp": {
      "user": ".*YiShuo.*"
    }
  }
}

3.11 根据当天时间查询（range + filter + now）

GET index_name/?search
{
  "query": {
    "bool": {
      "filter": {
        "range": {
          "timestamp": {
            "gte": "now/d",
            "lte": "now"
          }
        }
      }
    }
  }
}

3.12 根据自定义时间段查询（range + filter + datetime）

GET index_name/?search
{
  "query": {
    "bool": {
      "filter": {
        "range": {
          "timestamp": {
            "gte": "2023-12-01 00:00:00",
            "lt": "2023-12-02 23:59:59",
            "time_zone": "+08:00",
            "format": "yyyy-MM-dd HH:mm:ss"
          }
        }
      }
    }
  }
}

3.13 满足条件查询 （must）

GET index_name/?search
{
  "query": {
    "bool": {
      "filter": {
        "range": {
          "timestamp": {
            "gte": "2023-12-01 00:00:00",
            "lt": "2023-12-02 23:59:59",
            "time_zone": "+08:00",
            "format": "yyyy-MM-dd HH:mm:ss"
          }
        }
      },
      "must": [
        {
          "wildcard": {
            "command": "*"
          }
        },
        {
          "wildcard": {
            "ip": "192.*"
          }
        }
      ]
    }
  },
  "size": 1
}

3.14 排除条件查询（must_not）

GET index_name/?search
{
  "query": {
    "bool": {
      "filter": {
        "range": {
          "timestamp": {
            "gte": "2023-12-01 00:00:00",
            "lt": "2023-12-02 23:59:59",
            "time_zone": "+08:00",
            "format": "yyyy-MM-dd HH:mm:ss"
          }
        }
      },
      "must_not": [
        {
          "wildcard": {
            "ip": "127.*"
          }
        },
        {
          "wildcard": {
            "ip": "localhost*"
          }
        }
      ]
    }
  },
  "size": 1
}

3.15 包含key查询（must + exists）

GET index_name/?search
{
  "query": {
    "bool": {
      "must": [
        {
          "wildcard": {
            "user": "Yi*"
          }
        },
        {
          "exists": {
            "field": "address"
          }
        }
      ]
    }
  },
  "size": 1
}

3.16 不包含key查询（must_not + exists）

GET index_name/?search
{
  "query": {
    "bool": {
      "must": [
        {
          "wildcard": {
            "user": "Yi*"
          }
        }
      ],
      "not_must": [
        {
          "exists": {
            "field": "address"
          }
        }
      ]
    }
  },
  "size": 1
}

3.17 排序查询（sort）

3.17.1 降序

GET index_name/?search
{
  "query": {
    "wildcard": {
      "ip": "192.168.*"
    }
  },
  "sort": [
    {
      "timestamp": {
        "order": "desc"
      }
    }
  ]
}

3.17.2 升序

GET index_name/?search
{
  "query": {
    "wildcard": {
      "ip": "192.168.*"
    }
  },
  "sort": [
    {
      "timestamp": {
        "order": "asc"
      }
    }
  ]
}

3.18 指定返回字段查询（_source）

GET index_name/?search
{
  "query": {
    "wildcard": {
      "ip": "192.168.*"
    }
  },
  "sort": [
    {
      "timestamp": {
        "order": "desc"
      }
    }
  ],
  "_source": [
    "user",
    "ip",
    "phone",
    "address"
  ]
}

3.19 指定条数查询（size）

最多单次查询10000条，超过10000条需要分页查询。

GET index_name/?search
{
  "query": {
    "wildcard": {
      "ip": "192.168.*"
    }
  },
  "sort": [
    {
      "timestamp": {
        "order": "desc"
      }
    }
  ],
  "_source": [
    "user",
    "ip",
    "phone",
    "address"
  ],
  "size": 10000
}

3.20 分页查询（from）

GET index_name/?search
{
  "query": {
    "wildcard": {
      "ip": "192.168.*"
    }
  },
  "sort": [
    {
      "timestamp": {
        "order": "desc"
      }
    }
  ],
  "_source": [
    "user",
    "ip",
    "phone",
    "address"
  ],
  "from": 1,
  "size": 100
}

3.21 关联多个index查询

GET index_name_one,index_name_two/?search
{
  "query": {
    "bool": {
      "must": [
        {
          "wildcard": {
            "user": "Yi*"
          }
        }
      ],
      "must_not": [
        {
          "wildcard": {
            "ip": "127.*"
          }
        },
        {
          "wildcard": {
            "ip": "localhost*"
          }
        }
      ]
    }
  },
  "size": 1
}

GET index_name_*/?search
{
  "query": {
    "bool": {
      "must": [
        {
          "wildcard": {
            "user": "Yi*"
          }
        }
      ],
      "must_not": [
        {
          "wildcard": {
            "ip": "127.*"
          }
        },
        {
          "wildcard": {
            "ip": "localhost*"
          }
        }
      ]
    }
  },
  "size": 1
}

3.22 布尔查询（bool）

?? bool语句是常用的用于构建复杂查询逻辑的语句。bool语句可以通过组合多个条件子句来实现逻辑运算，包括must、must_not、should和filter。

3.22.1 bool+must查询

GET index_name/?search
{
  "query": {
    "bool": {
      "must": [
        {
          "wildcard": {
            "user": "Yi*"
          }
        }
      ],
      "must_not": [
        {
          "wildcard": {
            "ip": "127.*"
          }
        },
        {
          "wildcard": {
            "ip": "localhost*"
          }
        }
      ]
    }
  },
  "size": 1
}

3.22.2 bool+must_not查询

GET index_name/?search
{
  "query": {
    "bool": {
      "must": [
        {
          "wildcard": {
            "user": "Yi*"
          }
        }
      ],
      "must_not": [
        {
          "wildcard": {
            "ip": "127.*"
          }
        },
        {
          "wildcard": {
            "ip": "localhost*"
          }
        }
      ]
    }
  },
  "size": 1
}

3.22.3 bool+should查询

GET index_name/?search
{
  "track_total_hits": true,
  "query": {
    "bool": {
      "must": [
        {
          "bool": {
            "should": [
              {
                "wildcard": {
                  "host": "www.baidu.com"
                }
              },
              {
                "wildcard": {
                  "host": "www.qq.com"
                }
              }
            ]
          }
        },
        {
          "bool": {
            "should": [
              {
                "wildcard": {
                  "user": "*龙*"
                }
              },
              {
                "wildcard": {
                  "user": "*虎*"
                }
              }
            ]
          }
        }
      ]
    }
  },
  "sort": [
    {
      "timestamp": {
        "order": "desc"
      }
    }
  ],
  "size": 1
}

3.22.4 bool+filter查询

GET index_name/?search
{
  "track_total_hits": true,
  "query": {
    "bool": {
      "filter": {
        "range": {
          "timestamp": {
            "gte": "2023-11-27 00:00:00",
            "lt": "2023-12-03 23:59:59",
            "time_zone": "+08:00",
            "format": "yyyy-MM-dd HH:mm:ss"
          }
        }
      }
    }
  },
  "sort": [
    {
      "timestamp": {
        "order": "desc"
      }
    }
  ],
  "size": 0
}

3.22.5 bool多种组合（bool+must+must_not+should+filter）

GET index_name/?search
{
  "track_total_hits": true,
  "query": {
    "bool": {
      "filter": {
        "range": {
          "timestamp": {
            "gte": "2023-11-27 00:00:00",
            "lt": "2023-12-03 23:59:59",
            "time_zone": "+08:00",
            "format": "yyyy-MM-dd HH:mm:ss"
          }
        }
      },
      "must": [
        {
          "bool": {
            "should": [
              {
                "wildcard": {
                  "host": "www.baidu.com"
                }
              },
              {
                "wildcard": {
                  "host": "www.qq.com"
                }
              }
            ]
          }
        },
        {
          "bool": {
            "should": [
              {
                "wildcard": {
                  "user": "*龙*"
                }
              },
              {
                "wildcard": {
                  "user": "*虎*"
                }
              }
            ]
          }
        }
      ],
      "must_not": [
        {
          "wildcard": {
            "address": {
              "value": "*广东*"
            }
          }
        }
      ]
    }
  },
  "sort": [
    {
      "timestamp": {
        "order": "desc"
      }
    }
  ],
  "size": 0
}

3.23 match、term、terms、should、must_not、bool、filter区别

match查询是全文搜索查询，根据相关性匹配查询字符串，进行分词处理。
term查询是精确匹配查询，直接与文档中的词项进行比较，不进行分词处理。
terms查询是多值匹配查询，匹配多个值中的任意一个。
should查询表示满足任意一个条件即可匹配成功，用于构建OR逻辑关系。
must_not查询表示条件不能满足才能匹配成功，用于排除特定条件。
bool查询是复合查询，通过组合多个查询子句构建复杂的查询逻辑，包括must、should和must_not。
filter查询用于过滤文档，不计算相关性分数，仅根据条件进行精确匹配，提高查询性能。

四、DSL常用统计语句

4.1 aggs terms

GET index_name/?search
{
  "track_total_hits": true,
  "query": {
    "match_all": {}
  },
  "aggs": {
    "NAME": {
      "terms": {
        "field": "user",
        "size": 10
      }
    }
  }
}

4.2 aggs cardinality

GET index_name/?search
{
  "track_total_hits": true,
  "query": {
    "match_all": {}
  },
  "aggs": {
    "NAME": {
      "cardinality": {
        "field": "user"
      }
    }
  }
}

4.3 aggs value_count

GET index_name/?search
{
  "track_total_hits": true,
  "query": {
    "match_all": {}
  },
  "aggs": {
    "NAME": {
      "value_count": {
        "field": "user"
      }
    }
  }
}

4.4 aggs terms+script

GET index_name/?search
{
  "track_total_hits": true,
  "query": {
    "match_all": {}
  },
  "aggs": {
    "NAME": {
      "terms": {
        "script": "doc['user'] +'####'+ doc['ip']",
        "size": 1000
      }
    }
  }
}

4.5 aggs多重组合

GET index_name/?search
{
  "track_total_hits": true,
  "query": {
    "match_all": {}
  },
  "aggs": {
    "NAME": {
      "terms": {
        "field": "user",
        "size": 10
      },
      "aggs": {
        "NAME": {
          "terms": {
            "script": "doc['ip'] +'####'+ doc['address']",
            "size": 1000
          }
        }
      }
    }
  }
}

4.6 aggs语句参数解析

?? 这些聚合语句可以根据具体的需求进行组合和嵌套，以实现更复杂的统计和分析操作。通过使用这些聚合语句，可以从查询结果中提取有用的统计信息，进行数据分析、可视化和业务洞察。

terms聚合：按字段进行分组，并统计每个分组的文档数量。
date_histogram聚合：按时间间隔对日期字段进行分组，并统计每个时间间隔内的文档数量。
range聚合：将字段的值划分为不同的范围，并统计每个范围内的文档数量。
histogram聚合：将数值字段的值划分为不同的区间，并统计每个区间内的文档数量。
avg聚合：计算数值字段的平均值。
sum聚合：计算数值字段的总和。
min聚合：找到数值字段的最小值。
max聚合：找到数值字段的最大值。
cardinality聚合：计算字段的基数（不重复值的数量）。
top_hits聚合：返回每个分组中的顶部文档。
extended_stats聚合：计算数值字段的统计信息，包括平均值、标准差、最小值、最大值等。
percentiles聚合：计算数值字段的百分位数。
geo_distance聚合：按地理距离对地理坐标字段进行分组，并统计每个距离范围内的文档数量。
filter聚合：根据指定的过滤条件对文档进行聚合。
nested聚合：在嵌套的文档结构中进行聚合操作。
value_count聚合：计算某个字段的值的数量。
stats聚合：计算数值字段的统计信息，包括平均值、总和、最小值、最大值和文档数量。
scripted_metric聚合：使用自定义脚本计算聚合结果。

五、所遇到问题的解决方案

5.1 解决统计显示所有数量而不是10000问题

添加"track_total_hits": true

GET index_name/?search
{
	"track_total_hits": true, 
  "query": {
    "match_all": {
      
    }
  }
}

5.2 解决must与should同时使用must不生效问题

将should整个包装成must一个条件就能解决

GET index_name/?search
{
  "query": {
    "bool": {
      "must": [
        {
          "bool": {
            "should": [
              {
                "wildcard": {
                  "user": "*Yi*"
                }
              },
              {
                "wildcard": {
                  "user": "*龙*"
                }
              },
              {
                "wildcard": {
                  "user": "*虎*"
                }
              }
            ]
          }
        }
      ]
    }
  },
  "size": 10000
}

六、总结

?? 无论您是数据分析师、开发人员还是与Elasticsearch相关的岗位，了解和掌握ES DSL查询语句都是非常重要的，掌握这些强大的查询工具，为您的工作带来更多的效率和成果。微信公众号搜索关注艺说IT，分享各种原创技术干货文章，对你有用的话请一键三连，感谢🙏