カスタムDSLクエリのようなSQLをElasticSearchに変換しますか?


8

私たちは、antlr4を使用してMysqlに似た独自のクエリ言語を構築しています。を使用する場合を除いてwhere clause、つまり、ユーザーはselect/fromステートメントを入力しません。

文法を作成し、golangでレクサー/パーサー/リスナーを生成することができました。

文法ファイルEsDslQuery.g4の下:

grammar EsDslQuery;

options {
language = Go;
}

query
   : leftBracket = '(' query rightBracket = ')'                             #bracketExp
   | leftQuery=query op=OR rightQuery=query                                 #orLogicalExp
   | leftQuery=query op=AND rightQuery=query                                #andLogicalExp
   | propertyName=attrPath op=COMPARISON_OPERATOR propertyValue=attrValue   #compareExp
   ;

attrPath
   : ATTRNAME ('.' attrPath)?
   ;

fragment ATTR_NAME_CHAR
   : '-' | '_' | ':' | DIGIT | ALPHA
   ;

fragment DIGIT
   : ('0'..'9')
   ;

fragment ALPHA
   : ( 'A'..'Z' | 'a'..'z' )
   ;

attrValue
   : BOOLEAN           #boolean
   | NULL              #null
   | STRING            #string
   | DOUBLE            #double
   | '-'? INT EXP?     #long
   ;

...

クエリの例: color="red" and price=20000 or model="hyundai" and (seats=4 or year=2001)

ElasticSearchは、https//github.com/elastic/elasticsearch/tree/master/x-pack/plugin/sqlのプラグインを使用してSQLクエリをサポートします

Javaコードを理解するのに苦労している。

論理演算子があるので、解析ツリーを取得してESクエリに変換する方法がわかりません。誰かがアイデアを助けたり提案したりできますか?

更新1:対応するESクエリを含む例を追加しました

クエリ例1: color="red" AND price=2000

ESクエリ1:

{
    "query": {
      "bool": {
        "must": [
          {
            "terms": {
              "color": [
                "red"
              ]
            }
          },
          {
            "terms": {
              "price": [
                2000
              ]
            }
          }
        ]
      }
    },
    "size": 100
  }

クエリ例2: color="red" AND price=2000 AND (model="hyundai" OR model="bmw")

ESクエリ2:

{
  "query": {
    "bool": {
      "must": [
        {
          "bool": {
            "must": {
              "terms": {
                "color": ["red"]
              }
            }
          }
        },
        {
          "bool": {
            "must": {
              "terms": {
                "price": [2000]
              }
            }
          }
        },
        {
          "bool": {
            "should": [
              {
                "term": {
                  "model": "hyundai"
                }
              },
              {
                "term": {
                  "region": "bmw"
                }
              }
            ]
          }
        }
      ]
    }
  },
  "size": 100
}

クエリ例3: color="red" OR color="blue"

ESクエリ3:

{
    "query": {
      "bool": {
        "should": [
          {
            "bool": {
              "must": {
                "terms": {
                  "color": ["red"]
                }
              }
            }
          },
          {
            "bool": {
              "must": {
                "terms": {
                    "color": ["blue"]
                }
              }
            }
          }
        ]
      }
    },
    "size": 100
  }

いくつかの出力例を追加することを検討してください。color="red" and price=20000 or model="hyundai" and (seats=4 or year=2001ES構文ではどのように見えますか?あなたはJSON構文、または短いクエリ文字列構文、またはすべて一緒に違うものが欲しいですか?また、複数の例を追加すると役立ちます。また、あなたはすでに自分で何かを試しましたか?
バート・キアーズ

さらに例を追加しました。はい、解析ツリーからjson構文を構築したいと思います。私はgolangでそれをやっているのですが、まだ完成していません
Omurbek Kadyrbekov

回答:


6

作業デモURL:https : //github.com/omurbekjk/convert-dsl-to-es-query-with-antlr、推定所要時間:〜3週間

antlr4といくつかの例を調査した後、私はリスナーとスタックを使用した簡単な解決策を見つけました。スタックを使用して式を計算する方法に似ています。

Enter / Exit文法規則ごとにトリガーを取得するには、デフォルトの基本リスナーを上書きする必要があります。重要なルールは次のとおりです。

  1. 比較式(価格= 200、価格> 190)
  2. 論理演算子(OR、AND)
  3. ブラケット(クエリを正しく構築するには、演算子の優先順位を覚えて正しい文法ファイルを記述する必要があります。これが、文法ファイルの最初の場所にブラケットがある理由です)

golangで記述された私のカスタムリスナーコードの下:

package parser

import (
    "github.com/olivere/elastic"
    "strings"
)

type MyDslQueryListener struct {
    *BaseDslQueryListener
    Stack []*elastic.BoolQuery
}

func (ql *MyDslQueryListener) ExitCompareExp(c *CompareExpContext) {
    boolQuery := elastic.NewBoolQuery()

    attrName := c.GetPropertyName().GetText()
    attrValue := strings.Trim(c.GetPropertyValue().GetText(), `\"`)
    // Based on operator type we build different queries, default is terms query(=)
    termsQuery := elastic.NewTermQuery(attrName, attrValue)
    boolQuery.Must(termsQuery)
    ql.Stack = append(ql.Stack, boolQuery)
}

func (ql *MyDslQueryListener) ExitAndLogicalExp(c *AndLogicalExpContext) {
    size := len(ql.Stack)
    right := ql.Stack[size-1]
    left := ql.Stack[size-2]
    ql.Stack = ql.Stack[:size-2] // Pop last two elements
    boolQuery := elastic.NewBoolQuery()
    boolQuery.Must(right)
    boolQuery.Must(left)
    ql.Stack = append(ql.Stack, boolQuery)
}

func (ql *MyDslQueryListener) ExitOrLogicalExp(c *OrLogicalExpContext) {
    size := len(ql.Stack)
    right := ql.Stack[size-1]
    left := ql.Stack[size-2]
    ql.Stack = ql.Stack[:size-2] // Pop last two elements
    boolQuery := elastic.NewBoolQuery()
    boolQuery.Should(right)
    boolQuery.Should(left)
    ql.Stack = append(ql.Stack, boolQuery)
}

そしてメインファイル:

package main

import (
    "encoding/json"
    "fmt"
    "github.com/antlr/antlr4/runtime/Go/antlr"
    "github.com/omurbekjk/convert-dsl-to-es-query-with-antlr/parser"
)

func main() {
    fmt.Println("Starting here")
    query := "price=2000 OR model=\"hyundai\" AND (color=\"red\" OR color=\"blue\")"
    stream := antlr.NewInputStream(query)
    lexer := parser.NewDslQueryLexer(stream)
    tokenStream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
    dslParser := parser.NewDslQueryParser(tokenStream)
    tree := dslParser.Start()

    listener := &parser.MyDslQueryListener{}
    antlr.ParseTreeWalkerDefault.Walk(listener, tree)

    esQuery := listener.Stack[0]

    src, err := esQuery.Source()
    if err != nil {
        panic(err)
    }
    data, err := json.MarshalIndent(src, "", "  ")
    if err != nil {
        panic(err)
    }

    stringEsQuery := string(data)
    fmt.Println(stringEsQuery)
}

/**     Generated es query
{
  "bool": {
    "should": [
      {
        "bool": {
          "must": [
            {
              "bool": {
                "should": [
                  {
                    "bool": {
                      "must": {
                        "term": {
                          "color": "blue"
                        }
                      }
                    }
                  },
                  {
                    "bool": {
                      "must": {
                        "term": {
                          "color": "red"
                        }
                      }
                    }
                  }
                ]
              }
            },
            {
              "bool": {
                "must": {
                  "term": {
                    "model": "hyundai"
                  }
                }
              }
            }
          ]
        }
      },
      {
        "bool": {
          "must": {
            "term": {
              "price": "2000"
            }
          }
        }
      }
    ]
  }
}

*/

2

SQLのようなステートメントをクエリ文字列クエリに変換することを考えましたか?

curl -X GET "localhost:9200/_search?pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "query_string" : {
            "query" : "(new york city) OR (big apple)",
            "default_field" : "content"
        }
    }
}
'

あなたのユースケースがのように単純なままであればcolor="red" and price=20000 or model="hyundai" and (seats=4 or year=2001)、私は上記で行きます。構文は非常に強力ですが、ESパーサーがDSLに変換する必要があるため、クエリはネイティブのスペルアウトされたDSLクエリよりも実行が遅くなることが保証されています。


ここでは、渡されたプロパティの検証が必要になります。ユーザーが「価格」を誤って入力した場合、または数値を渡す代わりに無効な値を渡す場合を言います。(例: "price = adfasdf")
Omurbek Kadyrbekov

まあそれは別の話です。最初にマッピングを取得し(GET index_name/_mapping)、検索するユーザーに公開するフィールドを特定します(これにより、バリデーターまたは「平均」機能を構築できます)。フィールド値のデータ型を適用したい場合は、マッピングからその情報を抽出することもできます...
jzzfs

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.