/
listener.go
124 lines (108 loc) · 3.63 KB
/
listener.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
/*
* Copyright 2018 The Service Manager Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package query
import (
"fmt"
"strings"
"github.com/Peripli/service-manager/pkg/util"
"github.com/Peripli/service-manager/pkg/query/parser"
"github.com/antlr/antlr4/runtime/Go/antlr"
)
type queryListener struct {
*parser.BaseQueryListener
err error
leftOp string
rightOp []string
op string
criteriaType CriterionType
result []Criterion
}
// ExitUnivariate is called when production univariate is exited.
func (s *queryListener) ExitUnivariate(ctx *parser.UnivariateContext) {
if s.err != nil {
return
}
leftOp, operator, rightOp := getCriterionFields(ctx.Key(), ctx.UniOp(), ctx.Value())
s.leftOp = leftOp
s.op = operator
s.rightOp = []string{rightOp}
s.err = s.storeCriterion()
}
// ExitManyValues is called when production manyValues is exited.
func (s *queryListener) ExitManyValues(ctx *parser.ManyValuesContext) {
if s.err != nil {
return
}
_, _, rightOp := getCriterionFields(nil, nil, ctx.Value())
s.rightOp = append(s.rightOp, rightOp)
}
// ExitMultivariate is called when production univariate is exited.
func (s *queryListener) ExitMultivariate(ctx *parser.MultivariateContext) {
if s.err != nil {
return
}
leftOp, operator, _ := getCriterionFields(ctx.Key(), ctx.MultiOp(), nil)
s.leftOp = leftOp
s.op = operator
if s.rightOp == nil {
s.rightOp = []string{""}
}
s.err = s.storeCriterion()
}
func (s *queryListener) storeCriterion() error {
operator, err := findOpByString(s.op)
if err != nil {
return err
}
criterion := NewCriterion(s.leftOp, operator, s.rightOp, s.criteriaType)
if err = criterion.Validate(); err != nil {
return err
}
s.result = append(s.result, criterion)
s.rightOp = []string{}
return nil
}
func (s *queryListener) ReportAmbiguity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, exact bool, ambigAlts *antlr.BitSet, configs antlr.ATNConfigSet) {
}
func (s *queryListener) ReportAttemptingFullContext(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, conflictingAlts *antlr.BitSet, configs antlr.ATNConfigSet) {
}
func (s *queryListener) ReportContextSensitivity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex, prediction int, configs antlr.ATNConfigSet) {
}
func (s *queryListener) SyntaxError(recognizer antlr.Recognizer, offendingSymbol interface{}, line, column int, msg string, e antlr.RecognitionException) {
s.err = &util.UnsupportedQueryError{Message: fmt.Sprintf("error while parsing %s at column %d: %s", s.criteriaType, column, msg)}
}
func getCriterionFields(key, op, right antlr.TerminalNode) (leftOp string, operator string, rightOp string) {
if key != nil {
leftOp = key.GetText()
}
if right != nil {
rightOp = right.GetText()
rightOp = strings.Replace(rightOp, "''", "'", -1)
rightOp = strings.Trim(rightOp, "'")
}
if op != nil {
operator = op.GetText()
}
return
}
func findOpByString(op string) (Operator, error) {
for _, operator := range Operators {
if operator.String() == op {
return operator, nil
}
}
return nil, fmt.Errorf("provided operator %s is not supported", op)
}