feat: added exporter to ElasticSearch query

Author: Codehardt

export.go

@@ -4,76 +4,99 @@ import (
 	"encoding/json"
 )
 
+// ExportElasticSearchQuery exports the compiled query into an ElasticSearch query, e.g.
+// `"foo" OR "baz"` will be compiled to
+// {"bool":{"should":[{"wildcard":{"raw":{"case_insensitive":false,"value":"foo"}}},{"wildcard":{"raw":{"case_insensitive":false,"value":"bar"}}}]}}
 func (e *Evalostic) ExportElasticSearchQuery(wildcardField string) string {
 	indexToStrings := make(map[int]string)
 	for k, v := range e.strings {
 		indexToStrings[v] = k
 	}
-	query := e.exportElasticSearchQuery(wildcardField, indexToStrings, decisionTreeEntry{value: -1}, e.decisionTree)
+	query := e.exportElasticSearchQuerySub(wildcardField, indexToStrings, decisionTreeEntry{value: -1}, e.decisionTree)
 	if query == nil {
 		return ""
 	}
 	b, _ := json.Marshal(query)
 	return string(b)
 }
 
-func (e *Evalostic) exportElasticSearchQuery(wildcardField string, indexToStrings map[int]string, entry decisionTreeEntry, node *decisionTreeNode) interface{} {
-	var must []interface{}
-	var mustNot []interface{}
-	for entry, node := range node.children {
-		subQuery := e.exportElasticSearchQuery(wildcardField, indexToStrings, entry, node)
-		if subQuery != nil {
-			must = append(must, subQuery)
-		}
-	}
-	for entry, node := range node.notChildren {
-		subQuery := e.exportElasticSearchQuery(wildcardField, indexToStrings, entry, node)
-		if subQuery != nil {
-			mustNot = append(mustNot, subQuery)
-		}
-	}
-	var wildcard interface{}
-	if entry.value != -1 {
-		wildcard = map[string]interface{}{
-			"wildcard": map[string]interface{}{
-				wildcardField: map[string]interface{}{
-					"value":            indexToStrings[entry.value],
-					"case_insensitive": entry.ci,
-				},
+func (e *Evalostic) exportElasticSearchQuerySub(wildcardField string, indexToStrings map[int]string, entry decisionTreeEntry, node *decisionTreeNode) interface{} {
+
+	type Map map[string]interface{}
+
+	isLeaf := len(node.outputs) != 0
+	wildcard := Map{
+		"wildcard": Map{
+			wildcardField: Map{
+				"value":            indexToStrings[entry.value],
+				"case_insensitive": entry.ci,
 			},
-		}
+		},
 	}
-	if len(node.outputs) != 0 {
+	if entry.value == -1 {
+		// special case: do not use root node as wildcard
+		wildcard = nil
+	}
+	if isLeaf && wildcard != nil {
+		// special case: if it's a leaf, we don't need to process the sub tree
 		return wildcard
 	}
-	if len(must) == 0 && len(mustNot) == 0 {
-		return nil
+
+	var should, shouldNot []interface{}
+
+	for subEntry, subNode := range node.children {
+		if subQuery := e.exportElasticSearchQuerySub(wildcardField, indexToStrings, subEntry, subNode); subQuery != nil {
+			should = append(should, subQuery)
+		}
 	}
-	boolRes := make(map[string]interface{})
-	if len(must) != 0 {
-		boolRes["should"] = must
+	for subEntry, subNode := range node.notChildren {
+		if subQuery := e.exportElasticSearchQuerySub(wildcardField, indexToStrings, subEntry, subNode); subQuery != nil {
+			shouldNot = append(shouldNot, subQuery)
+		}
 	}
-	if len(mustNot) != 0 {
-		if len(mustNot) == 1 {
-			boolRes["must_not"] = mustNot
+
+	toQuery := func(should []interface{}, not bool) interface{} {
+		if len(should) == 0 {
+			return nil
+		}
+		var res interface{}
+		if len(should) == 1 {
+			res = should[0]
 		} else {
-			boolRes["must_not"] = map[string]interface{}{
-				"bool": map[string]interface{}{
-					"should": mustNot,
+			res = Map{
+				"bool": Map{
+					"should": should,
+				},
+			}
+		}
+		if not {
+			// wrap OR conditions with a NOT
+			res = Map{
+				"bool": Map{
+					"must_not": []interface{}{res},
 				},
 			}
 		}
+		return res
+	}
+
+	notChildQuery := toQuery(shouldNot, true)
+	if notChildQuery != nil {
+		should = append(should, notChildQuery)
+	}
+	childQuery := toQuery(should, false)
+	if childQuery == nil {
+		return nil
 	}
 	if wildcard == nil {
-		return map[string]interface{}{"bool": boolRes}
+		return childQuery
 	}
-	res := map[string]interface{}{
-		"bool": map[string]interface{}{
+	return Map{
+		"bool": Map{
 			"must": []interface{}{
 				wildcard,
-				map[string]interface{}{"bool": boolRes},
+				childQuery,
 			},
 		},
 	}
-	return res
 }

export_test.go

@@ -8,6 +8,8 @@ func TestElasticSearchQueryExport(t *testing.T) {
 		`"foo" OR "bar"`,
 		`"foo" AND "bar"`,
 		`"foo" AND NOT "bar"`,
+		`"foo" OR ("bar" AND NOT "baz")`,
+		`"foo" OR NOT ("bar" AND NOT "baz")`,
 		`("foo" OR "bar") AND NOT ("bar" AND ("baz" OR "qux"))`,
 	} {
 		ev, err := New([]string{condition})