ES Query DSL

Query DSL

Elasticsearch provides a full Query DSL (Domain Specific Language) based on JSON to define queries. Think of the Query DSL as an AST (Abstract Syntax Tree) of queries, consisting of two types of clauses:
Leaf query clauses
Leaf query clauses look for a particular value in a particular field, such as the match, term or range queries. These queries can be used by themselves.
Compound query clauses
Compound query clauses wrap other leaf or compound queries and are used to combine multiple queries in a logical fashion (such as the bool or dis_max query), or to alter their behaviour (such as the constant_score query).
Query clauses behave differently depending on whether they are used in query context or filter context.

查询构造

Ref: https://blog.csdn.net/weixin_39913422/article/details/111218265

等值查询

BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery()
    .must(QueryBuilders.termQuery("name", "小李"));

相当于：

{
    "query": {
        "bool": {
            "adjust_pure_negative": true,
            "must": [
                {
                    "term": {
                        "name": {
                            "boost": 1,
                            "value": "小李"
                        }
                    }
                }
            ],
            "boost": 1
        }
    }
}

范围查询

BoolQueryBuilder queryBuilder = QueryBuilders.rangeQuery("age").gte(18).lte(50);

相当于：

{
    "query": {
        "range": {
            "age": {
                "include_lower": true,
                "include_upper": true,
                "from": 18,
                "boost": 1,
                "to": 50
            }
        }
    }
}

模糊查询

BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery()
    .must(QueryBuilders.wildcardQuery("name", "*小李*"));

相当于：

{
    "query": {
        "bool": {
            "adjust_pure_negative": true,
            "must": [
                {
                    "wildcard": {
                        "name": {
                            "boost": 1,
                            "wildcard": "*小李*"
                        }
                    }
                }
            ],
            "boost": 1
        }
    }
}

多条件查询

BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery()
    .must(QueryBuilders.termQuery("name", "小李"))
    .must(QueryBuilders.rangeQuery("age").gte(10).lte(50));

查询姓名为：小李，并且年龄在10-50之间的文档，等同于以下命令：

{
    "query": {
        "bool": {
            "adjust_pure_negative": true,
            "must": [
                {
                    "term": {
                        "name": {
                            "boost": 1.0,
                            "value": "小李"
                        }
                    }
                },
                {
                    "range": {
                        "age": {
                            "include_lower": true,
                            "include_upper": true,
                            "from": 10,
                            "boost": 1.0,
                            "to": 50
                        }
                    }
                }
            ],
            "boost": 1.0
        }
    }
}

集合查询

List < String > list = Arrays.asList("北京", "上海", "杭州");
BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery()
    .must(QueryBuilders.termQuery("name", "李明"))
    .must(QueryBuilders.termsQuery("address", list))
    .must(QueryBuilders.rangeQuery("age").gte(10).lte(50));

查询地址在北京、上海、杭州，并且年龄在10至50，名字叫做李明的文档，等同于以下命令：

{
    "query": {
        "bool": {
            "adjust_pure_negative": true,
            "must": [
                {
                    "term": {
                        "name": {
                            "boost": 1.0,
                            "value": "李明"
                        }
                    }
                },
                {
                    "terms": {
                        "address": [
                            "北京",
                            "上海",
                            "杭州"
                        ],
                        "boost": 1.0
                    }
                },
                {
                    "range": {
                        "age": {
                            "include_lower": true,
                            "include_upper": true,
                            "from": 10,
                            "boost": 1.0,
                            "to": 50
                        }
                    }
                }
            ],
            "boost": 1.0
        }
    }
}

使用 should 查询

BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery()
    .should(QueryBuilders.wildcardQuery("name", "*小李*"))
    .should(QueryBuilders.termQuery("address", "北京"));

查询姓名包含小李或者是地址是北京的记录，should 相当于 or，命令如下：

{
    "query":
    {
        "bool":
        {
            "adjust_pure_negative": true,
            "should": [
            {
                "wildcard":
                {
                    "name":
                    {
                        "boost": 1.0,
                        "wildcard": "*小李*"
                    }
                }
            },
            {
                "term":
                {
                    "address":
                    {
                        "boost": 1.0,
                        "value": "北京"
                    }
                }
            }],
            "boost": 1.0
        }
    }
}

should 和 must 组合查询

BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery()
    .must(QueryBuilders.termQuery("sex", "男"))
    .should(QueryBuilders.wildcardQuery("name", "*小李*"))
    .should(QueryBuilders.termQuery("address", "北京"))
    .minimumShouldMatch(1);

查询性别为男，姓名包含小李或地址为北京的记录，minimumShouldMatch(1) 表示最少要匹配到一个 should 条件。相当于以下命令：

{
    "query":
    {
        "bool":
        {
            "adjust_pure_negative": true,
            "should": [
            {
                "wildcard":
                {
                    "name":
                    {
                        "boost": 1.0,
                        "wildcard": "*小李*"
                    }
                }
            },
            {
                "term":
                {
                    "address":
                    {
                        "boost": 1.0,
                        "value": "北京"
                    }
                }
            }],
            "minimum_should_match": "1",
            "must": [
            {
                "term":
                {
                    "sex":
                    {
                        "boost": 1.0,
                        "value": "男"
                    }
                }
            }],
            "boost": 1.0
        }
    }
}
{
    "query":
    {
        "bool":
        {
            "adjust_pure_negative": true,
            "should": [
            {
                "wildcard":
                {
                    "name":
                    {
                        "boost": 1.0,
                        "wildcard": "*小李*"
                    }
                }
            },
            {
                "term":
                {
                    "address":
                    {
                        "boost": 1.0,
                        "value": "北京"
                    }
                }
            }],
            "minimum_should_match": "1",
            "must": [
            {
                "term":
                {
                    "sex":
                    {
                        "boost": 1.0,
                        "value": "男"
                    }
                }
            }],
            "boost": 1.0
        }
    }
}

有值查询

BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery()
    .must(QueryBuilders.existsQuery("name"))
    .mustNot(QueryBuilders.existsQuery("tag"));

查询 name 有值，tag 不存在值的文档，命令如下：

{
    "query":
    {
        "bool":
        {
            "adjust_pure_negative": true,
            "must_not": [
            {
                "exists":
                {
                    "field": "tag",
                    "boost": 1.0
                }
            }],
            "must": [
            {
                "exists":
                {
                    "field": "name",
                    "boost": 1.0
                }
            }],
            "boost": 1.0
        }
    }
}

分页查询

SearchResponse response = this.transportClient.prepareSearch(index)
    .setTypes(type)
    .setQuery(queryBuilder)
    .setFrom(offset)
    .setSize(rows)
    .setExplain(false)
    .execute().actionGet();

普通分页查询数据，相当于以下命令：

{
    "from": 0,
    "size": 10,
    "query":
    {
        "bool":
        {
            "adjust_pure_negative": true,
            "must": [
            {
                "term":
                {
                    "name":
                    {
                        "boost": 1.0,
                        "value": "小李"
                    }
                }
            }],
            "boost": 1.0
        }
    }
}

基于 scrollId 查询的API如下：

SearchResponse scrollResp = null;
String scrollId = ContextParameterHolder.get("scrollId");
if(scrollId != null)
{
    scrollResp = getTransportClient().prepareSearchScroll(scrollId).setScroll(new TimeValue(60000)).execute().actionGet();
}
else
{
    log.info("基于scroll的分页查询，scrollId为空");
    scrollResp = this.prepareSearch()
        .setSearchType(SearchType.QUERY_AND_FETCH)
        .setScroll(new TimeValue(60000))
        .setQuery(queryBuilder)
        .setSize(page.getPageSize()).execute().actionGet();
    ContextParameterHolder.set("scrollId", scrollResp.getScrollId());
}