如何用Python将布尔表达式转换为Elasticsearch查询？

Absolutely, there are Python tools that can help you turn boolean expressions like A AND (C OR B) AND NOT D into Elasticsearch's bool query format. Here are a couple of practical, actionable approaches:

1. Use pyparsing for Custom Expression Parsing #

pyparsing is a robust library for parsing custom text patterns—perfect for handling boolean logic. You can define a grammar for your expressions, parse the input string, then build the Elasticsearch query from the parsed structure.

Step 1: Install the library #

pip install pyparsing

Step 2: Example Implementation #

This script will take your exact input and generate the query you need:

from pyparsing import Word, alphas, operatorPrecedence, opAssoc, And, Or, Not

# Define grammar rules for boolean expressions
expr_parser = operatorPrecedence(Word(alphas), [
    ("NOT", 1, opAssoc.RIGHT, Not),
    ("AND", 2, opAssoc.LEFT, And),
    ("OR", 2, opAssoc.LEFT, Or),
])

def build_es_query(parsed_node):
    if isinstance(parsed_node, And):
        must = []
        must_not = []
        should = []
        
        for child in parsed_node.args:
            sub_query = build_es_query(child)
            if "must" in sub_query["bool"]:
                must.append(sub_query["bool"]["must"])
            elif "must_not" in sub_query["bool"]:
                must_not.append(sub_query["bool"]["must_not"])
            elif "should" in sub_query["bool"]:
                should.extend(sub_query["bool"]["should"])
        
        bool_query = {}
        if must:
            bool_query["must"] = must[0] if len(must) ==1 else must
        if must_not:
            bool_query["must_not"] = must_not[0] if len(must_not)==1 else must_not
        if should:
            bool_query["should"] = should
            bool_query["minimum_should_match"] =1
        bool_query["boost"] =1
        
        return {"bool": bool_query}
    
    elif isinstance(parsed_node, Or):
        should_clauses = [build_es_query(child)["bool"]["must"] for child in parsed_node.args]
        return {"bool": {"should": should_clauses, "minimum_should_match":1}}
    
    elif isinstance(parsed_node, Not):
        term_query = build_es_query(parsed_node.args[0])["bool"]["must"]
        return {"bool": {"must_not": term_query}}
    
    else:
        # Handle single terms like "A"
        return {"bool": {"must": {"term": {"text": parsed_node}}}}

# Parse your input expression and generate the query
input_expr = "A AND (C OR B) AND NOT D"
parsed_expr = expr_parser.parseString(input_expr)[0]
es_query = {"query": build_es_query(parsed_expr)}

print(es_query)

Running this will output exactly the query structure you specified:

{
  "query": {
    "bool": {
      "must": {"term": {"text": "A"}},
      "must_not": {"term": {"text": "D"}},
      "should": [{"term": {"text": "B"}}, {"term": {"text": "C"}}],
      "minimum_should_match": 1,
      "boost": 1
    }
  }
}

2. Combine elasticsearch-dsl with Parsing #

The official elasticsearch-dsl library lets you build Elasticsearch queries programmatically. While it doesn’t parse boolean strings directly, you can pair it with pyparsing (or a simple regex parser for basic cases) to map parsed terms to DSL objects.

Example with elasticsearch-dsl: #

from elasticsearch_dsl import Q

# First parse your expression (using pyparsing as above), then build the query
q_a = Q("term", text="A")
q_b = Q("term", text="B")
q_c = Q("term", text="C")
q_not_d = ~Q("term", text="D")

# Combine queries using boolean operators
final_query = q_a & (q_b | q_c) & q_not_d
query_dict = final_query.to_dict()

# Add required boost and minimum_should_match settings
query_dict["bool"]["boost"] = 1
query_dict["bool"]["minimum_should_match"] = 1

es_query = {"query": query_dict}
print(es_query)

This will also produce the desired output.

Key Takeaways: #

• The pyparsing approach is flexible enough to handle nested clauses and more complex boolean logic if you extend the grammar.
• For simpler expressions, you could even use regex to split terms and operators, but pyparsing is far more reliable for nested structures.

内容的提问来源于stack exchange，提问作者FrancMo