将中缀表达式转换为弹性搜索查询

Question

How can I convert an infix expression to an elastic search query
my operators are ! + * ! + *
and user may make any expression using those operators, something like:
(((A*B*(!C))*(D*E))+F)*G
and I wish to convert it to a bool query in elastic search

Edit
I don't know why I didn't say this earlier but I have already written a code to convert infix to postfix expression and then I call a very dirty recursive method to create should (+), must (*) and must_not (!) but what i'm seeking is an optimized way to do the trick for me.

My query at the end is something like this which I think is very very nasty:

{
  "from": 0,
  "size": 10,
  "_source": [
    "*"
  ],
  "index": "insta_userpost_new2",
  "body": {
    "query": {
      "bool": {
        "must": [
          {
            "match_phrase": {
              "caption.text": "G"
            }
          },
          {
            "bool": {
              "should": [
                {
                  "match_phrase": {
                    "caption.text": "F"
                  }
                },
                {
                  "bool": {
                    "must": [
                      {
                        "bool": {
                          "must": [
                            {
                              "match_phrase": {
                                "caption.text": "E"
                              }
                            },
                            {
                              "match_phrase": {
                                "caption.text": "D"
                              }
                            }
                          ]
                        }
                      },
                      {
                        "bool": {
                          "must": [
                            {
                              "bool": {
                                "must_not": [
                                  {
                                    "match_phrase": {
                                      "caption.text": "C"
                                    }
                                  },
                                  {
                                    "bool": {
                                      "must": [
                                        {
                                          "match_phrase": {
                                            "caption.text": "B"
                                          }
                                        },
                                        {
                                          "match_phrase": {
                                            "caption.text": "A"
                                          }
                                        }
                                      ]
                                    }
                                  }
                                ]
                              }
                            }
                          ]
                        }
                      }
                    ]
                  }
                }
              ]
            }
          }
        ]
      }
    }
  }
}

Answer 1

I would maybe try to leverage simply_query_string . For that, you'd have to:

• replace + by | (for the OR )
• then replace * by + (for the AND )
• finally replace ! by - (for the NOT )

So if a user inputs this:

(((A*B*(!C))*(D*E))+F)*G

You'd end up with this

(((A+B+(-C))+(D+E))|F)+G

Which is a boolean expression that you can directly use in a simply_query_string query.

GET /_search
{
    "query": {
        "simple_query_string" : {
            "fields" : ["content"],
            "query" : "(((A+B+(-C))+(D+E))|F)+G"
        }
    }
}

Answer 2

You can use Elasticsearch scripts in queries, like this: https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-script-query.html

There are few scripting options, with the most simple and strait forward is 'Painless' scripts. From elastic documentation:

When you define a scripted field in Kibana, you have a choice of scripting languages. Starting with 5.0, the default options are Lucene expressions and Painless

Also you can return the result of the calculation using Scripted Fields: https://www.elastic.co/guide/en/kibana/current/scripted-fields.html

Answer 3

You can run an infix expression evaluation[1] and replace the standard eval operations with DSL bool query composers.

We actually do something akin to this for https://opensource.appbase.io/mirage/ (you can try it live), where we map GUI blocks to a composable bool query. The source code is viewable at https://github.com/appbaseio/mirage .

[1] Ref: https://www.geeksforgeeks.org/expression-evaluation/