apitech
/
prometheus
mirror of https://github.com/prometheus/prometheus
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Fix all build errors in promql package

Browse Source 
Signed-off-by: Tobias Guggenmos <tguggenm@redhat.com>
pull/6744/head
Tobias Guggenmos 6 years ago
parent 2164e366ea
commit 1360f9ff12
9 changed files with 256 additions and 256 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 144
      promql/engine.go
  2. 22
      promql/functions.go
  3. 20
      promql/parser/generated_parser.y
  4. 226
      promql/parser/generated_parser.y.go
  5. 20
      promql/parser/lex.go
  6. 34
      promql/parser/parse.go
  7. 2
      promql/parser/parse_test.go
  8. 2
      promql/parser/printer.go
  9. 42
      promql/test.go

144
promql/engine.go
Unescape View File

@ -1265,19 +1265,19 @@ func (ev *evaluator) eval(expr parser.Expr) parser.Value {
}, e.LHS, e.RHS)
}
case *NumberLiteral:
case *parser.NumberLiteral:
return ev.rangeEval(func(v []parser.Value, enh *EvalNodeHelper) Vector {
return append(enh.out, Sample{Point: Point{V: e.Val}})
})
case *parser.VectorSelector:
checkForSeriesSetExpansion(ev.ctx, e)
mat := make(Matrix, 0, len(e.series))
mat := make(Matrix, 0, len(e.Series))
it := storage.NewBuffer(durationMilliseconds(ev.lookbackDelta))
for i, s := range e.series {
for i, s := range e.Series {
it.Reset(s.Iterator())
ss := Series{
Metric: e.series[i].Labels(),
Metric: e.Series[i].Labels(),
Points: getPointSlice(numSteps),
}
@ -1336,7 +1336,7 @@ func (ev *evaluator) eval(expr parser.Expr) parser.Value {
res := newEv.eval(e.Expr)
ev.currentSamples = newEv.currentSamples
return res
case *StringLiteral:
case *parser.StringLiteral:
return String{V: e.Val, T: ev.startTimestamp}
}
@ -1352,17 +1352,17 @@ func (ev *evaluator) vectorSelector(node *parser.VectorSelector, ts int64) Vecto
checkForSeriesSetExpansion(ev.ctx, node)
var (
vec = make(Vector, 0, len(node.series))
vec = make(Vector, 0, len(node.Series))
)
it := storage.NewBuffer(durationMilliseconds(ev.lookbackDelta))
for i, s := range node.series {
for i, s := range node.Series {
it.Reset(s.Iterator())
t, v, ok := ev.vectorSelectorSingle(it, node, ts)
if ok {
vec = append(vec, Sample{
Metric: node.series[i].Labels(),
Metric: node.Series[i].Labels(),
Point: Point{V: v, T: t},
})
ev.currentSamples++
@ -1389,7 +1389,7 @@ func (ev *evaluator) vectorSelectorSingle(it *storage.BufferedSeriesIterator, no
}
if ok {
t, v = it.parser.Values()
t, v = it.Values()
}
if !ok || t > refTime {
@ -1429,11 +1429,11 @@ func (ev *evaluator) matrixSelector(node *parser.MatrixSelector) Matrix {
offset = durationMilliseconds(vs.Offset)
maxt = ev.startTimestamp - offset
mint = maxt - durationMilliseconds(node.Range)
matrix = make(Matrix, 0, len(vs.series))
matrix = make(Matrix, 0, len(vs.Series))
)
it := storage.NewBuffer(durationMilliseconds(node.Range))
series := vs.series
series := vs.Series
for i, s := range series {
if err := contextDone(ev.ctx, "expression evaluation"); err != nil {
@ -1505,7 +1505,7 @@ func (ev *evaluator) matrixIterSlice(it *storage.BufferedSeriesIterator, mint, m
}
// The seeked sample might also be in the range.
if ok {
t, v := it.parser.Values()
t, v := it.Values()
if t == maxt && !value.IsStaleNaN(v) {
if ev.currentSamples >= ev.maxSamples {
ev.error(ErrTooManySamples(env))
@ -1518,7 +1518,7 @@ func (ev *evaluator) matrixIterSlice(it *storage.BufferedSeriesIterator, mint, m
}
func (ev *evaluator) VectorAnd(lhs, rhs Vector, matching *parser.VectorMatching, enh *EvalNodeHelper) Vector {
if matching.Card != CardManyToMany {
if matching.Card != parser.CardManyToMany {
panic("set operations must only use many-to-many matching")
}
sigf := enh.signatureFunc(matching.On, matching.MatchingLabels...)
@ -1540,7 +1540,7 @@ func (ev *evaluator) VectorAnd(lhs, rhs Vector, matching *parser.VectorMatching,
}
func (ev *evaluator) VectorOr(lhs, rhs Vector, matching *parser.VectorMatching, enh *EvalNodeHelper) Vector {
if matching.Card != CardManyToMany {
if matching.Card != parser.CardManyToMany {
panic("set operations must only use many-to-many matching")
}
sigf := enh.signatureFunc(matching.On, matching.MatchingLabels...)
@ -1561,7 +1561,7 @@ func (ev *evaluator) VectorOr(lhs, rhs Vector, matching *parser.VectorMatching,
}
func (ev *evaluator) VectorUnless(lhs, rhs Vector, matching *parser.VectorMatching, enh *EvalNodeHelper) Vector {
if matching.Card != CardManyToMany {
if matching.Card != parser.CardManyToMany {
panic("set operations must only use many-to-many matching")
}
sigf := enh.signatureFunc(matching.On, matching.MatchingLabels...)
@ -1581,7 +1581,7 @@ func (ev *evaluator) VectorUnless(lhs, rhs Vector, matching *parser.VectorMatchi
// VectorBinop evaluates a binary operation between two Vectors, excluding set operators.
func (ev *evaluator) VectorBinop(op parser.ItemType, lhs, rhs Vector, matching *parser.VectorMatching, returnBool bool, enh *EvalNodeHelper) Vector {
if matching.Card == CardManyToMany {
if matching.Card == parser.CardManyToMany {
panic("many-to-many only allowed for set operators")
}
sigf := enh.signatureFunc(matching.On, matching.MatchingLabels...)
@ -1589,7 +1589,7 @@ func (ev *evaluator) VectorBinop(op parser.ItemType, lhs, rhs Vector, matching *
// The control flow below handles one-to-one or many-to-one matching.
// For one-to-many, swap sidedness and account for the swap when calculating
// values.
if matching.Card == CardOneToMany {
if matching.Card == parser.CardOneToMany {
lhs, rhs = rhs, lhs
}
@ -1611,7 +1611,7 @@ func (ev *evaluator) VectorBinop(op parser.ItemType, lhs, rhs Vector, matching *
if duplSample, found := rightSigs[sig]; found {
// oneSide represents which side of the vector represents the 'one' in the many-to-one relationship.
oneSide := "right"
if matching.Card == CardOneToMany {
if matching.Card == parser.CardOneToMany {
oneSide = "left"
}
matchedLabels := rs.Metric.MatchLabels(matching.On, matching.MatchingLabels...)
@ -1645,7 +1645,7 @@ func (ev *evaluator) VectorBinop(op parser.ItemType, lhs, rhs Vector, matching *
// Account for potentially swapped sidedness.
vl, vr := ls.V, rs.V
if matching.Card == CardOneToMany {
if matching.Card == parser.CardOneToMany {
vl, vr = vr, vl
}
value, keep := vectorElemBinop(op, vl, vr)
@ -1661,7 +1661,7 @@ func (ev *evaluator) VectorBinop(op parser.ItemType, lhs, rhs Vector, matching *
metric := resultMetric(ls.Metric, rs.Metric, op, matching, enh)
insertedSigs, exists := matchedSigs[sig]
if matching.Card == CardOneToOne {
if matching.Card == parser.CardOneToOne {
if exists {
ev.errorf("multiple matches for labels: many-to-one matching must be explicit (group_left/group_right)")
}
@ -1727,7 +1727,7 @@ func resultMetric(lhs, rhs labels.Labels, op parser.ItemType, matching *parser.V
lb.Del(labels.MetricName)
}
if matching.Card == CardOneToOne {
if matching.Card == parser.CardOneToOne {
if matching.On {
Outer:
for _, l := range lhs {
@ -1768,7 +1768,7 @@ func (ev *evaluator) VectorscalarBinop(op parser.ItemType, lhs Vector, rhs Scala
value, keep := vectorElemBinop(op, lv, rv)
// Catch cases where the scalar is the LHS in a scalar-vector comparison operation.
// We want to always keep the vector element value as the output value, even if it's on the RHS.
if op.isComparisonOperator() && swap {
if op.IsComparisonOperator() && swap {
value = rv
}
if returnBool {
@ -1797,29 +1797,29 @@ func dropMetricName(l labels.Labels) labels.Labels {
// scalarBinop evaluates a binary operation between two Scalars.
func scalarBinop(op parser.ItemType, lhs, rhs float64) float64 {
switch op {
case ADD:
case parser.ADD:
return lhs + rhs
case SUB:
case parser.SUB:
return lhs - rhs
case MUL:
case parser.MUL:
return lhs * rhs
case DIV:
case parser.DIV:
return lhs / rhs
case POW:
case parser.POW:
return math.Pow(lhs, rhs)
case MOD:
case parser.MOD:
return math.Mod(lhs, rhs)
case EQL:
case parser.EQL:
return btos(lhs == rhs)
case NEQ:
case parser.NEQ:
return btos(lhs != rhs)
case GTR:
case parser.GTR:
return btos(lhs > rhs)
case LSS:
case parser.LSS:
return btos(lhs < rhs)
case GTE:
case parser.GTE:
return btos(lhs >= rhs)
case LTE:
case parser.LTE:
return btos(lhs <= rhs)
}
panic(errors.Errorf("operator %q not allowed for Scalar operations", op))
@ -1828,29 +1828,29 @@ func scalarBinop(op parser.ItemType, lhs, rhs float64) float64 {
// vectorElemBinop evaluates a binary operation between two Vector elements.
func vectorElemBinop(op parser.ItemType, lhs, rhs float64) (float64, bool) {
switch op {
case ADD:
case parser.ADD:
return lhs + rhs, true
case SUB:
case parser.SUB:
return lhs - rhs, true
case MUL:
case parser.MUL:
return lhs * rhs, true
case DIV:
case parser.DIV:
return lhs / rhs, true
case POW:
case parser.POW:
return math.Pow(lhs, rhs), true
case MOD:
case parser.MOD:
return math.Mod(lhs, rhs), true
case EQL:
case parser.EQL:
return lhs, lhs == rhs
case NEQ:
case parser.NEQ:
return lhs, lhs != rhs
case GTR:
case parser.GTR:
return lhs, lhs > rhs
case LSS:
case parser.LSS:
return lhs, lhs < rhs
case GTE:
case parser.GTE:
return lhs, lhs >= rhs
case LTE:
case parser.LTE:
return lhs, lhs <= rhs
}
panic(errors.Errorf("operator %q not allowed for operations between Vectors", op))
@ -1870,7 +1870,7 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
result := map[uint64]*groupedAggregation{}
var k int64
if op == TOPK || op == BOTTOMK {
if op == parser.TOPK || op == parser.BOTTOMK {
f := param.(float64)
if !convertibleToInt64(f) {
ev.errorf("Scalar value %v overflows int64", f)
@ -1881,11 +1881,11 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
}
}
var q float64
if op == QUANTILE {
if op == parser.QUANTILE {
q = param.(float64)
}
var valueLabel string
if op == COUNT_VALUES {
if op == parser.COUNT_VALUES {
valueLabel = param.(string)
if !model.LabelName(valueLabel).IsValid() {
ev.errorf("invalid label name %q", valueLabel)
@ -1901,7 +1901,7 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
for _, s := range vec {
metric := s.Metric
if op == COUNT_VALUES {
if op == parser.COUNT_VALUES {
lb.Reset(metric)
lb.Set(valueLabel, strconv.FormatFloat(s.V, 'f', -1, 64))
metric = lb.Labels()
@ -1949,15 +1949,15 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
if k > inputVecLen {
resultSize = inputVecLen
}
if op == STDVAR || op == STDDEV {
if op == parser.STDVAR || op == parser.STDDEV {
result[groupingKey].value = 0.0
} else if op == TOPK || op == QUANTILE {
} else if op == parser.TOPK || op == parser.QUANTILE {
result[groupingKey].heap = make(vectorByValueHeap, 0, resultSize)
heap.Push(&result[groupingKey].heap, &Sample{
Point: Point{V: s.V},
Metric: s.Metric,
})
} else if op == BOTTOMK {
} else if op == parser.BOTTOMK {
result[groupingKey].reverseHeap = make(vectorByReverseValueHeap, 0, resultSize)
heap.Push(&result[groupingKey].reverseHeap, &Sample{
Point: Point{V: s.V},
@ -1968,33 +1968,33 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
}
switch op {
case SUM:
case parser.SUM:
group.value += s.V
case AVG:
case parser.AVG:
group.groupCount++
group.mean += (s.V - group.mean) / float64(group.groupCount)
case MAX:
case parser.MAX:
if group.value < s.V || math.IsNaN(group.value) {
group.value = s.V
}
case MIN:
case parser.MIN:
if group.value > s.V || math.IsNaN(group.value) {
group.value = s.V
}
case COUNT, COUNT_VALUES:
case parser.COUNT, parser.COUNT_VALUES:
group.groupCount++
case STDVAR, STDDEV:
case parser.STDVAR, parser.STDDEV:
group.groupCount++
delta := s.V - group.mean
group.mean += delta / float64(group.groupCount)
group.value += delta * (s.V - group.mean)
case TOPK:
case parser.TOPK:
if int64(len(group.heap)) < k || group.heap[0].V < s.V || math.IsNaN(group.heap[0].V) {
if int64(len(group.heap)) == k {
heap.Pop(&group.heap)
@ -2005,7 +2005,7 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
})
}
case BOTTOMK:
case parser.BOTTOMK:
if int64(len(group.reverseHeap)) < k || group.reverseHeap[0].V > s.V || math.IsNaN(group.reverseHeap[0].V) {
if int64(len(group.reverseHeap)) == k {
heap.Pop(&group.reverseHeap)
@ -2016,7 +2016,7 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
})
}
case QUANTILE:
case parser.QUANTILE:
group.heap = append(group.heap, s)
default:
@ -2027,19 +2027,19 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
// Construct the result Vector from the aggregated groups.
for _, aggr := range result {
switch op {
case AVG:
case parser.AVG:
aggr.value = aggr.mean
case COUNT, COUNT_VALUES:
case parser.COUNT, parser.COUNT_VALUES:
aggr.value = float64(aggr.groupCount)
case STDVAR:
case parser.STDVAR:
aggr.value = aggr.value / float64(aggr.groupCount)
case STDDEV:
case parser.STDDEV:
aggr.value = math.Sqrt(aggr.value / float64(aggr.groupCount))
case TOPK:
case parser.TOPK:
// The heap keeps the lowest value on top, so reverse it.
sort.Sort(sort.Reverse(aggr.heap))
for _, v := range aggr.heap {
@ -2050,7 +2050,7 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
}
continue // Bypass default append.
case BOTTOMK:
case parser.BOTTOMK:
// The heap keeps the lowest value on top, so reverse it.
sort.Sort(sort.Reverse(aggr.reverseHeap))
for _, v := range aggr.reverseHeap {
@ -2061,7 +2061,7 @@ func (ev *evaluator) aggregation(op parser.ItemType, grouping []string, without
}
continue // Bypass default append.
case QUANTILE:
case parser.QUANTILE:
aggr.value = quantile(q, aggr.heap)
default:
@ -2088,7 +2088,7 @@ func btos(b bool) float64 {
// result of the op operation.
func shouldDropMetricName(op parser.ItemType) bool {
switch op {
case ADD, SUB, DIV, MUL, POW, MOD:
case parser.ADD, parser.SUB, parser.DIV, parser.MUL, parser.POW, parser.MOD:
return true
default:
return false
@ -2107,8 +2107,8 @@ func formatDate(t time.Time) string {
// unwrapParenExpr does the AST equivalent of removing parentheses around a expression.
func unwrapParenExpr(e *parser.Expr) {
for {
if p, ok := (*e).(*ParenExpr); ok {
*e = p.parser.Expr
if p, ok := (*e).(*parser.ParenExpr); ok {
*e = p.Expr
} else {
break
}

22
promql/functions.go
Unescape View File

@ -58,7 +58,7 @@ func funcTime(vals []parser.Value, args parser.Expressions, enh *EvalNodeHelper)
// the result as either per-second (if isRate is true) or overall.
func extrapolatedRate(vals []parser.Value, args parser.Expressions, enh *EvalNodeHelper, isCounter bool, isRate bool) Vector {
ms := args[0].(*parser.MatrixSelector)
vs := ms.parser.VectorSelector.(*parser.VectorSelector)
vs := ms.VectorSelector.(*parser.VectorSelector)
var (
samples = vals[0].(Matrix)[0]
@ -683,10 +683,10 @@ func funcChanges(vals []parser.Value, args parser.Expressions, enh *EvalNodeHelp
func funcLabelReplace(vals []parser.Value, args parser.Expressions, enh *EvalNodeHelper) Vector {
var (
vector = vals[0].(Vector)
dst = args[1].(*StringLiteral).Val
repl = args[2].(*StringLiteral).Val
src = args[3].(*StringLiteral).Val
regexStr = args[4].(*StringLiteral).Val
dst = args[1].(*parser.StringLiteral).Val
repl = args[2].(*parser.StringLiteral).Val
src = args[3].(*parser.StringLiteral).Val
regexStr = args[4].(*parser.StringLiteral).Val
)
if enh.regex == nil {
@ -746,8 +746,8 @@ func funcVector(vals []parser.Value, args parser.Expressions, enh *EvalNodeHelpe
func funcLabelJoin(vals []parser.Value, args parser.Expressions, enh *EvalNodeHelper) Vector {
var (
vector = vals[0].(Vector)
dst = args[1].(*StringLiteral).Val
sep = args[2].(*StringLiteral).Val
dst = args[1].(*parser.StringLiteral).Val
sep = args[2].(*parser.StringLiteral).Val
srcLabels = make([]string, len(args)-3)
)
@ -756,7 +756,7 @@ func funcLabelJoin(vals []parser.Value, args parser.Expressions, enh *EvalNodeHe
}
for i := 3; i < len(args); i++ {
src := args[i].(*StringLiteral).Val
src := args[i].(*parser.StringLiteral).Val
if !model.LabelName(src).IsValid() {
panic(errors.Errorf("invalid source label name in label_join(): %s", src))
}
@ -889,7 +889,7 @@ var FunctionCalls = map[string]FunctionCall{
"floor": funcFloor,
"histogram_quantile": funcHistogramQuantile,
"holt_winters": funcHoltWinters,
"hour": parser.ValueTypeVector,
"hour": funcHour,
"idelta": funcIdelta,
"increase": funcIncrease,
"irate": funcIrate,
@ -994,7 +994,7 @@ func createLabelsForAbsentFunction(expr parser.Expr) labels.Labels {
case *parser.VectorSelector:
lm = n.LabelMatchers
case *parser.MatrixSelector:
lm = n.parser.VectorSelector.(*parser.VectorSelector).LabelMatchers
lm = n.VectorSelector.(*parser.VectorSelector).LabelMatchers
default:
return m
}
@ -1005,7 +1005,7 @@ func createLabelsForAbsentFunction(expr parser.Expr) labels.Labels {
continue
}
if ma.Type == labels.MatchEqual && !m.Has(ma.Name) {
m = labels.NewBuilder(m).Set(ma.Name, ma.parser.Value).Labels()
m = labels.NewBuilder(m).Set(ma.Name, ma.Value).Labels()
} else {
empty = append(empty, ma.Name)
}

20
promql/parser/generated_parser.y
Unescape View File

@ -33,7 +33,7 @@ import (
label labels.Label
labels labels.Labels
strings []string
series []sequenceValue
series []SequenceValue
uint uint64
float float64
duration time.Duration
@ -577,7 +577,7 @@ series_description: metric series_values
;
series_values : /*empty*/
{ $$ = []sequenceValue{} }
{ $$ = []SequenceValue{} }
| series_values SPACE series_item
{ $$ = append($1, $3...) }
| series_values SPACE
@ -587,28 +587,28 @@ series_values : /*empty*/
;
series_item : BLANK
{ $$ = []sequenceValue{{omitted: true}}}
{ $$ = []SequenceValue{{Omitted: true}}}
| BLANK TIMES uint
{
$$ = []sequenceValue{}
$$ = []SequenceValue{}
for i:=uint64(0); i < $3; i++{
$$ = append($$, sequenceValue{omitted: true})
$$ = append($$, SequenceValue{Omitted: true})
}
}
| series_value
{ $$ = []sequenceValue{{value: $1}}}
{ $$ = []SequenceValue{{Value: $1}}}
| series_value TIMES uint
{
$$ = []sequenceValue{}
$$ = []SequenceValue{}
for i:=uint64(0); i <= $3; i++{
$$ = append($$, sequenceValue{value: $1})
$$ = append($$, SequenceValue{Value: $1})
}
}
| series_value signed_number TIMES uint
{
$$ = []sequenceValue{}
$$ = []SequenceValue{}
for i:=uint64(0); i <= $4; i++{
$$ = append($$, sequenceValue{value: $1})
$$ = append($$, SequenceValue{Value: $1})
$1 += $2
}
}

226
promql/parser/generated_parser.y.go
Unescape View File

@ -1,11 +1,11 @@
// Code generated by goyacc -o promql/generated_parser.y.go promql/generated_parser.y. DO NOT EDIT.
// Code generated by goyacc -o generated_parser.y.go generated_parser.y. DO NOT EDIT.
//line promql/generated_parser.y:15
//line generated_parser.y:15
package parser
import __yyfmt__ "fmt"
//line promql/generated_parser.y:15
//line generated_parser.y:15
import (
"math"
@ -17,7 +17,7 @@ import (
"github.com/prometheus/prometheus/pkg/value"
)
//line promql/generated_parser.y:28
//line generated_parser.y:28
type yySymType struct {
yys int
node Node
@ -183,7 +183,7 @@ const yyEofCode = 1
const yyErrCode = 2
const yyInitialStackSize = 16
//line promql/generated_parser.y:706
//line generated_parser.y:706
//line yacctab:1
var yyExca = [...]int{
@ -786,62 +786,62 @@ yydefault:
case 1:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:164
//line generated_parser.y:164
{
yylex.(*parser).generatedParserResult = yyDollar[2].labels
}
case 3:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:167
//line generated_parser.y:167
{
yylex.(*parser).addParseErrf(PositionRange{}, "no expression found in input")
}
case 4:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:169
//line generated_parser.y:169
{
yylex.(*parser).generatedParserResult = yyDollar[2].node
}
case 5:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:171
//line generated_parser.y:171
{
yylex.(*parser).generatedParserResult = yyDollar[2].node
}
case 7:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:174
//line generated_parser.y:174
{
yylex.(*parser).unexpected("", "")
}
case 19:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:196
//line generated_parser.y:196
{
yyVAL.node = yylex.(*parser).newAggregateExpr(yyDollar[1].item, yyDollar[2].node, yyDollar[3].node)
}
case 20:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:198
//line generated_parser.y:198
{
yyVAL.node = yylex.(*parser).newAggregateExpr(yyDollar[1].item, yyDollar[3].node, yyDollar[2].node)
}
case 21:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:200
//line generated_parser.y:200
{
yyVAL.node = yylex.(*parser).newAggregateExpr(yyDollar[1].item, &AggregateExpr{}, yyDollar[2].node)
}
case 22:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:202
//line generated_parser.y:202
{
yylex.(*parser).unexpected("aggregation", "")
yyVAL.node = nil
}
case 23:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:207
//line generated_parser.y:207
{
yyVAL.node = &AggregateExpr{
Grouping: yyDollar[2].strings,
@ -849,7 +849,7 @@ yydefault:
}
case 24:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:213
//line generated_parser.y:213
{
yyVAL.node = &AggregateExpr{
Grouping: yyDollar[2].strings,
@ -858,97 +858,97 @@ yydefault:
}
case 25:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:226
//line generated_parser.y:226
{
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
}
case 26:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:227
//line generated_parser.y:227
{
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
}
case 27:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:228
//line generated_parser.y:228
{
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
}
case 28:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:229
//line generated_parser.y:229
{
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
}
case 29:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:230
//line generated_parser.y:230
{
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
}
case 30:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:231
//line generated_parser.y:231
{
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
}
case 31:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:232
//line generated_parser.y:232
{
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
}
case 32:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:233
//line generated_parser.y:233
{
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
}
case 33:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:234
//line generated_parser.y:234
{
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
}
case 34:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:235
//line generated_parser.y:235
{
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
}
case 35:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:236
//line generated_parser.y:236
{
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
}
case 36:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:237
//line generated_parser.y:237
{
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
}
case 37:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:238
//line generated_parser.y:238
{
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
}
case 38:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:239
//line generated_parser.y:239
{
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
}
case 39:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:240
//line generated_parser.y:240
{
yyVAL.node = yylex.(*parser).newBinaryExpression(yyDollar[1].node, yyDollar[2].item, yyDollar[3].node, yyDollar[4].node)
}
case 41:
yyDollar = yyS[yypt-0 : yypt+1]
//line promql/generated_parser.y:248
//line generated_parser.y:248
{
yyVAL.node = &BinaryExpr{
VectorMatching: &VectorMatching{Card: CardOneToOne},
@ -956,7 +956,7 @@ yydefault:
}
case 42:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:253
//line generated_parser.y:253
{
yyVAL.node = &BinaryExpr{
VectorMatching: &VectorMatching{Card: CardOneToOne},
@ -965,14 +965,14 @@ yydefault:
}
case 43:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:261
//line generated_parser.y:261
{
yyVAL.node = yyDollar[1].node
yyVAL.node.(*BinaryExpr).VectorMatching.MatchingLabels = yyDollar[3].strings
}
case 44:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:266
//line generated_parser.y:266
{
yyVAL.node = yyDollar[1].node
yyVAL.node.(*BinaryExpr).VectorMatching.MatchingLabels = yyDollar[3].strings
@ -980,7 +980,7 @@ yydefault:
}
case 47:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:276
//line generated_parser.y:276
{
yyVAL.node = yyDollar[1].node
yyVAL.node.(*BinaryExpr).VectorMatching.Card = CardManyToOne
@ -988,7 +988,7 @@ yydefault:
}
case 48:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:282
//line generated_parser.y:282
{
yyVAL.node = yyDollar[1].node
yyVAL.node.(*BinaryExpr).VectorMatching.Card = CardOneToMany
@ -996,51 +996,51 @@ yydefault:
}
case 49:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:291
//line generated_parser.y:291
{
yyVAL.strings = yyDollar[2].strings
}
case 50:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:293
//line generated_parser.y:293
{
yyVAL.strings = yyDollar[2].strings
}
case 51:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:295
//line generated_parser.y:295
{
yyVAL.strings = []string{}
}
case 52:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:297
//line generated_parser.y:297
{
yylex.(*parser).unexpected("grouping opts", "\"(\"")
yyVAL.strings = nil
}
case 53:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:303
//line generated_parser.y:303
{
yyVAL.strings = append(yyDollar[1].strings, yyDollar[3].item.Val)
}
case 54:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:305
//line generated_parser.y:305
{
yyVAL.strings = []string{yyDollar[1].item.Val}
}
case 55:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:307
//line generated_parser.y:307
{
yylex.(*parser).unexpected("grouping opts", "\",\" or \")\"")
yyVAL.strings = yyDollar[1].strings
}
case 56:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:311
//line generated_parser.y:311
{
if !isLabel(yyDollar[1].item.Val) {
yylex.(*parser).unexpected("grouping opts", "label")
@ -1049,14 +1049,14 @@ yydefault:
}
case 57:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:318
//line generated_parser.y:318
{
yylex.(*parser).unexpected("grouping opts", "label")
yyVAL.item = Item{}
}
case 58:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:326
//line generated_parser.y:326
{
fn, exist := getFunction(yyDollar[1].item.Val)
if !exist {
@ -1073,58 +1073,58 @@ yydefault:
}
case 59:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:343
//line generated_parser.y:343
{
yyVAL.node = yyDollar[2].node
}
case 60:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:345
//line generated_parser.y:345
{
yyVAL.node = Expressions{}
}
case 61:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:349
//line generated_parser.y:349
{
yyVAL.node = append(yyDollar[1].node.(Expressions), yyDollar[3].node.(Expr))
}
case 62:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:351
//line generated_parser.y:351
{
yyVAL.node = Expressions{yyDollar[1].node.(Expr)}
}
case 63:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:353
//line generated_parser.y:353
{
yylex.(*parser).addParseErrf(yyDollar[2].item.PositionRange(), "trailing commas not allowed in function call args")
yyVAL.node = yyDollar[1].node
}
case 64:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:364
//line generated_parser.y:364
{
yyVAL.node = &ParenExpr{Expr: yyDollar[2].node.(Expr), PosRange: mergeRanges(&yyDollar[1].item, &yyDollar[3].item)}
}
case 65:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:372
//line generated_parser.y:372
{
yylex.(*parser).addOffset(yyDollar[1].node, yyDollar[3].duration)
yyVAL.node = yyDollar[1].node
}
case 66:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:377
//line generated_parser.y:377
{
yylex.(*parser).unexpected("offset", "duration")
yyVAL.node = yyDollar[1].node
}
case 67:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:385
//line generated_parser.y:385
{
var errMsg string
vs, ok := yyDollar[1].node.(*VectorSelector)
@ -1147,7 +1147,7 @@ yydefault:
}
case 68:
yyDollar = yyS[yypt-6 : yypt+1]
//line promql/generated_parser.y:408
//line generated_parser.y:408
{
yyVAL.node = &SubqueryExpr{
Expr: yyDollar[1].node.(Expr),
@ -1159,35 +1159,35 @@ yydefault:
}
case 69:
yyDollar = yyS[yypt-6 : yypt+1]
//line promql/generated_parser.y:418
//line generated_parser.y:418
{
yylex.(*parser).unexpected("subquery selector", "\"]\"")
yyVAL.node = yyDollar[1].node
}
case 70:
yyDollar = yyS[yypt-5 : yypt+1]
//line promql/generated_parser.y:420
//line generated_parser.y:420
{
yylex.(*parser).unexpected("subquery selector", "duration or \"]\"")
yyVAL.node = yyDollar[1].node
}
case 71:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:422
//line generated_parser.y:422
{
yylex.(*parser).unexpected("subquery or range", "\":\" or \"]\"")
yyVAL.node = yyDollar[1].node
}
case 72:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:424
//line generated_parser.y:424
{
yylex.(*parser).unexpected("subquery selector", "duration")
yyVAL.node = yyDollar[1].node
}
case 73:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:434
//line generated_parser.y:434
{
if nl, ok := yyDollar[2].node.(*NumberLiteral); ok {
if yyDollar[1].item.Typ == SUB {
@ -1201,7 +1201,7 @@ yydefault:
}
case 74:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:452
//line generated_parser.y:452
{
vs := yyDollar[2].node.(*VectorSelector)
vs.PosRange = mergeRanges(&yyDollar[1].item, vs)
@ -1211,7 +1211,7 @@ yydefault:
}
case 75:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:460
//line generated_parser.y:460
{
vs := &VectorSelector{
Name: yyDollar[1].item.Val,
@ -1223,7 +1223,7 @@ yydefault:
}
case 76:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:470
//line generated_parser.y:470
{
vs := yyDollar[1].node.(*VectorSelector)
yylex.(*parser).assembleVectorSelector(vs)
@ -1231,7 +1231,7 @@ yydefault:
}
case 77:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:478
//line generated_parser.y:478
{
yyVAL.node = &VectorSelector{
LabelMatchers: yyDollar[2].matchers,
@ -1240,7 +1240,7 @@ yydefault:
}
case 78:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:485
//line generated_parser.y:485
{
yyVAL.node = &VectorSelector{
LabelMatchers: yyDollar[2].matchers,
@ -1249,7 +1249,7 @@ yydefault:
}
case 79:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:492
//line generated_parser.y:492
{
yyVAL.node = &VectorSelector{
LabelMatchers: []*labels.Matcher{},
@ -1258,7 +1258,7 @@ yydefault:
}
case 80:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:501
//line generated_parser.y:501
{
if yyDollar[1].matchers != nil {
yyVAL.matchers = append(yyDollar[1].matchers, yyDollar[3].matcher)
@ -1268,130 +1268,130 @@ yydefault:
}
case 81:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:509
//line generated_parser.y:509
{
yyVAL.matchers = []*labels.Matcher{yyDollar[1].matcher}
}
case 82:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:511
//line generated_parser.y:511
{
yylex.(*parser).unexpected("label matching", "\",\" or \"}\"")
yyVAL.matchers = yyDollar[1].matchers
}
case 83:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:515
//line generated_parser.y:515
{
yyVAL.matcher = yylex.(*parser).newLabelMatcher(yyDollar[1].item, yyDollar[2].item, yyDollar[3].item)
}
case 84:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:517
//line generated_parser.y:517
{
yylex.(*parser).unexpected("label matching", "string")
yyVAL.matcher = nil
}
case 85:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:519
//line generated_parser.y:519
{
yylex.(*parser).unexpected("label matching", "label matching operator")
yyVAL.matcher = nil
}
case 86:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:521
//line generated_parser.y:521
{
yylex.(*parser).unexpected("label matching", "identifier or \"}\"")
yyVAL.matcher = nil
}
case 87:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:529
//line generated_parser.y:529
{
yyVAL.labels = append(yyDollar[2].labels, labels.Label{Name: labels.MetricName, Value: yyDollar[1].item.Val})
sort.Sort(yyVAL.labels)
}
case 88:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:531
//line generated_parser.y:531
{
yyVAL.labels = yyDollar[1].labels
}
case 91:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:538
//line generated_parser.y:538
{
yyVAL.labels = labels.New(yyDollar[2].labels...)
}
case 92:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:540
//line generated_parser.y:540
{
yyVAL.labels = labels.New(yyDollar[2].labels...)
}
case 93:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:542
//line generated_parser.y:542
{
yyVAL.labels = labels.New()
}
case 94:
yyDollar = yyS[yypt-0 : yypt+1]
//line promql/generated_parser.y:544
//line generated_parser.y:544
{
yyVAL.labels = labels.New()
}
case 95:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:548
//line generated_parser.y:548
{
yyVAL.labels = append(yyDollar[1].labels, yyDollar[3].label)
}
case 96:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:550
//line generated_parser.y:550
{
yyVAL.labels = []labels.Label{yyDollar[1].label}
}
case 97:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:552
//line generated_parser.y:552
{
yylex.(*parser).unexpected("label set", "\",\" or \"}\"")
yyVAL.labels = yyDollar[1].labels
}
case 98:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:557
//line generated_parser.y:557
{
yyVAL.label = labels.Label{Name: yyDollar[1].item.Val, Value: yylex.(*parser).unquoteString(yyDollar[3].item.Val)}
}
case 99:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:559
//line generated_parser.y:559
{
yylex.(*parser).unexpected("label set", "string")
yyVAL.label = labels.Label{}
}
case 100:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:561
//line generated_parser.y:561
{
yylex.(*parser).unexpected("label set", "\"=\"")
yyVAL.label = labels.Label{}
}
case 101:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:563
//line generated_parser.y:563
{
yylex.(*parser).unexpected("label set", "identifier or \"}\"")
yyVAL.label = labels.Label{}
}
case 102:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:571
//line generated_parser.y:571
{
yylex.(*parser).generatedParserResult = &seriesDescription{
labels: yyDollar[1].labels,
@ -1400,72 +1400,72 @@ yydefault:
}
case 103:
yyDollar = yyS[yypt-0 : yypt+1]
//line promql/generated_parser.y:580
//line generated_parser.y:580
{
yyVAL.series = []SequenceValue{}
}
case 104:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:582
//line generated_parser.y:582
{
yyVAL.series = append(yyDollar[1].series, yyDollar[3].series...)
}
case 105:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:584
//line generated_parser.y:584
{
yyVAL.series = yyDollar[1].series
}
case 106:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:586
//line generated_parser.y:586
{
yylex.(*parser).unexpected("series values", "")
yyVAL.series = nil
}
case 107:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:590
//line generated_parser.y:590
{
yyVAL.series = []SequenceValue{{omitted: true}}
yyVAL.series = []SequenceValue{{Omitted: true}}
}
case 108:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:592
//line generated_parser.y:592
{
yyVAL.series = []SequenceValue{}
for i := uint64(0); i < yyDollar[3].uint; i++ {
yyVAL.series = append(yyVAL.series, SequenceValue{omitted: true})
yyVAL.series = append(yyVAL.series, SequenceValue{Omitted: true})
}
}
case 109:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:599
//line generated_parser.y:599
{
yyVAL.series = []SequenceValue{{value: yyDollar[1].float}}
yyVAL.series = []SequenceValue{{Value: yyDollar[1].float}}
}
case 110:
yyDollar = yyS[yypt-3 : yypt+1]
//line promql/generated_parser.y:601
//line generated_parser.y:601
{
yyVAL.series = []SequenceValue{}
for i := uint64(0); i <= yyDollar[3].uint; i++ {
yyVAL.series = append(yyVAL.series, SequenceValue{value: yyDollar[1].float})
yyVAL.series = append(yyVAL.series, SequenceValue{Value: yyDollar[1].float})
}
}
case 111:
yyDollar = yyS[yypt-4 : yypt+1]
//line promql/generated_parser.y:608
//line generated_parser.y:608
{
yyVAL.series = []SequenceValue{}
for i := uint64(0); i <= yyDollar[4].uint; i++ {
yyVAL.series = append(yyVAL.series, SequenceValue{value: yyDollar[1].float})
yyVAL.series = append(yyVAL.series, SequenceValue{Value: yyDollar[1].float})
yyDollar[1].float += yyDollar[2].float
}
}
case 112:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:618
//line generated_parser.y:618
{
if yyDollar[1].item.Val != "stale" {
yylex.(*parser).unexpected("series values", "number or \"stale\"")
@ -1474,7 +1474,7 @@ yydefault:
}
case 155:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:649
//line generated_parser.y:649
{
yyVAL.node = &NumberLiteral{
Val: yylex.(*parser).number(yyDollar[1].item.Val),
@ -1483,25 +1483,25 @@ yydefault:
}
case 156:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:657
//line generated_parser.y:657
{
yyVAL.float = yylex.(*parser).number(yyDollar[1].item.Val)
}
case 157:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:659
//line generated_parser.y:659
{
yyVAL.float = yyDollar[2].float
}
case 158:
yyDollar = yyS[yypt-2 : yypt+1]
//line promql/generated_parser.y:660
//line generated_parser.y:660
{
yyVAL.float = -yyDollar[2].float
}
case 159:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:664
//line generated_parser.y:664
{
var err error
yyVAL.uint, err = strconv.ParseUint(yyDollar[1].item.Val, 10, 64)
@ -1511,7 +1511,7 @@ yydefault:
}
case 160:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:674
//line generated_parser.y:674
{
var err error
yyVAL.duration, err = parseDuration(yyDollar[1].item.Val)
@ -1521,7 +1521,7 @@ yydefault:
}
case 161:
yyDollar = yyS[yypt-1 : yypt+1]
//line promql/generated_parser.y:685
//line generated_parser.y:685
{
yyVAL.node = &StringLiteral{
Val: yylex.(*parser).unquoteString(yyDollar[1].item.Val),
@ -1530,13 +1530,13 @@ yydefault:
}
case 162:
yyDollar = yyS[yypt-0 : yypt+1]
//line promql/generated_parser.y:698
//line generated_parser.y:698
{
yyVAL.duration = 0
}
case 164:
yyDollar = yyS[yypt-0 : yypt+1]
//line promql/generated_parser.y:702
//line generated_parser.y:702
{
yyVAL.strings = nil
}

20
promql/parser/lex.go
Unescape View File

@ -36,11 +36,11 @@ func (i Item) String() string {
return i.Val
case i.Typ == IDENTIFIER || i.Typ == METRIC_IDENTIFIER:
return fmt.Sprintf("%q", i.Val)
case i.Typ.isKeyword():
case i.Typ.IsKeyword():
return fmt.Sprintf("<%s>", i.Val)
case i.Typ.isOperator():
case i.Typ.IsOperator():
return fmt.Sprintf("<op:%s>", i.Val)
case i.Typ.isAggregator():
case i.Typ.IsAggregator():
return fmt.Sprintf("<aggr:%s>", i.Val)
case len(i.Val) > 10:
return fmt.Sprintf("%.10q...", i.Val)
@ -50,25 +50,25 @@ func (i Item) String() string {
// isOperator returns true if the Item corresponds to a arithmetic or set operator.
// Returns false otherwise.
func (i ItemType) isOperator() bool { return i > operatorsStart && i < operatorsEnd }
func (i ItemType) IsOperator() bool { return i > operatorsStart && i < operatorsEnd }
// isAggregator returns true if the Item belongs to the aggregator functions.
// Returns false otherwise
func (i ItemType) isAggregator() bool { return i > aggregatorsStart && i < aggregatorsEnd }
func (i ItemType) IsAggregator() bool { return i > aggregatorsStart && i < aggregatorsEnd }
// isAggregator returns true if the Item is an aggregator that takes a parameter.
// Returns false otherwise
func (i ItemType) isAggregatorWithParam() bool {
func (i ItemType) IsAggregatorWithParam() bool {
return i == TOPK || i == BOTTOMK || i == COUNT_VALUES || i == QUANTILE
}
// isKeyword returns true if the Item corresponds to a keyword.
// Returns false otherwise.
func (i ItemType) isKeyword() bool { return i > keywordsStart && i < keywordsEnd }
func (i ItemType) IsKeyword() bool { return i > keywordsStart && i < keywordsEnd }
// isComparisonOperator returns true if the Item corresponds to a comparison operator.
// IsComparisonOperator returns true if the Item corresponds to a comparison operator.
// Returns false otherwise.
func (i ItemType) isComparisonOperator() bool {
func (i ItemType) IsComparisonOperator() bool {
switch i {
case EQL, NEQ, LTE, LSS, GTE, GTR:
return true
@ -78,7 +78,7 @@ func (i ItemType) isComparisonOperator() bool {
}
// isSetOperator returns whether the Item corresponds to a set operator.
func (i ItemType) isSetOperator() bool {
func (i ItemType) IsSetOperator() bool {
switch i {
case LAND, LOR, LUNLESS:
return true

34
promql/parser/parse.go
Unescape View File

@ -57,14 +57,14 @@ type ParseErr struct {
Err error
Query string
// An additional line offset to be added. Only used inside unit tests.
lineOffset int
// LineOffset is an additional line offset to be added. Only used inside unit tests.
LineOffset int
}
func (e *ParseErr) Error() string {
pos := int(e.PositionRange.Start)
lastLineBreak := -1
line := e.lineOffset + 1
line := e.LineOffset + 1
var positionStr string
@ -180,15 +180,15 @@ func newParser(input string) *parser {
// SequenceValue is an omittable value in a sequence of time series values.
type SequenceValue struct {
value float64
omitted bool
Value float64
Omitted bool
}
func (v SequenceValue) String() string {
if v.omitted {
if v.Omitted {
return "_"
}
return fmt.Sprintf("%f", v.value)
return fmt.Sprintf("%f", v.Value)
}
type seriesDescription struct {
@ -196,8 +196,8 @@ type seriesDescription struct {
values []SequenceValue
}
// parseSeriesDesc parses the description of a time series.
func parseSeriesDesc(input string) (labels labels.Labels, values []SequenceValue, err error) {
// ParseSeriesDesc parses the description of a time series.
func ParseSeriesDesc(input string) (labels labels.Labels, values []SequenceValue, err error) {
p := newParser(input)
p.lex.seriesDesc = true
@ -382,7 +382,7 @@ func (p *parser) newAggregateExpr(op Item, modifier Node, args Node) (ret *Aggre
}
desiredArgs := 1
if ret.Op.isAggregatorWithParam() {
if ret.Op.IsAggregatorWithParam() {
desiredArgs = 2
ret.Param = arguments[0]
@ -450,7 +450,7 @@ func (p *parser) checkAST(node Node) (typ ValueType) {
}
}
case *AggregateExpr:
if !n.Op.isAggregator() {
if !n.Op.IsAggregator() {
p.addParseErrf(n.PositionRange(), "aggregation operator expected in aggregation expression but got %q", n.Op)
}
p.expectType(n.Expr, ValueTypeVector, "aggregation expression")
@ -476,15 +476,15 @@ func (p *parser) checkAST(node Node) (typ ValueType) {
return
}
if n.ReturnBool && !n.Op.isComparisonOperator() {
if n.ReturnBool && !n.Op.IsComparisonOperator() {
p.addParseErrf(opRange(), "bool modifier can only be used on comparison operators")
}
if n.Op.isComparisonOperator() && !n.ReturnBool && n.RHS.Type() == ValueTypeScalar && n.LHS.Type() == ValueTypeScalar {
if n.Op.IsComparisonOperator() && !n.ReturnBool && n.RHS.Type() == ValueTypeScalar && n.LHS.Type() == ValueTypeScalar {
p.addParseErrf(opRange(), "comparisons between scalars must use BOOL modifier")
}
if n.Op.isSetOperator() && n.VectorMatching.Card == CardOneToOne {
if n.Op.IsSetOperator() && n.VectorMatching.Card == CardOneToOne {
n.VectorMatching.Card = CardManyToMany
}
@ -496,7 +496,7 @@ func (p *parser) checkAST(node Node) (typ ValueType) {
}
}
if !n.Op.isOperator() {
if !n.Op.IsOperator() {
p.addParseErrf(n.PositionRange(), "binary expression does not support operator %q", n.Op)
}
if lt != ValueTypeScalar && lt != ValueTypeVector {
@ -513,7 +513,7 @@ func (p *parser) checkAST(node Node) (typ ValueType) {
n.VectorMatching = nil
} else {
// Both operands are Vectors.
if n.Op.isSetOperator() {
if n.Op.IsSetOperator() {
if n.VectorMatching.Card == CardOneToMany || n.VectorMatching.Card == CardManyToOne {
p.addParseErrf(n.PositionRange(), "no grouping allowed for %q operation", n.Op)
}
@ -523,7 +523,7 @@ func (p *parser) checkAST(node Node) (typ ValueType) {
}
}
if (lt == ValueTypeScalar || rt == ValueTypeScalar) && n.Op.isSetOperator() {
if (lt == ValueTypeScalar || rt == ValueTypeScalar) && n.Op.IsSetOperator() {
p.addParseErrf(n.PositionRange(), "set operator %q not allowed in binary scalar expression", n.Op)
}

2
promql/parser/parse_test.go
Unescape View File

@ -2615,7 +2615,7 @@ func newSeq(vals ...float64) (res []SequenceValue) {
func TestParseSeries(t *testing.T) {
for _, test := range testSeries {
metric, vals, err := parseSeriesDesc(test.input)
metric, vals, err := ParseSeriesDesc(test.input)
// Unexpected errors are always caused by a bug.
testutil.Assert(t, err != errUnexpected, "unexpected error occurred")

2
promql/parser/printer.go
Unescape View File

@ -72,7 +72,7 @@ func (node *AggregateExpr) String() string {
}
aggrString += "("
if node.Op.isAggregatorWithParam() {
if node.Op.IsAggregatorWithParam() {
aggrString += fmt.Sprintf("%s, ", node.Param)
}
aggrString += fmt.Sprintf("%s)", node.Expr)

42
promql/test.go
Unescape View File

@ -103,7 +103,7 @@ func (t *Test) Storage() storage.Storage {
func raise(line int, format string, v ...interface{}) error {
return &parser.ParseErr{
lineOffset: line,
LineOffset: line,
Err: errors.Errorf(format, v...),
}
}
@ -114,7 +114,7 @@ func parseLoad(lines []string, i int) (int, *loadCmd, error) {
}
parts := patLoad.FindStringSubmatch(lines[i])
gap, err := model.parser.ParseDuration(parts[1])
gap, err := model.ParseDuration(parts[1])
if err != nil {
return i, nil, raise(i, "invalid step definition %q: %s", parts[1], err)
}
@ -126,10 +126,10 @@ func parseLoad(lines []string, i int) (int, *loadCmd, error) {
i--
break
}
metric, vals, err := parseSeriesDesc(defLine)
metric, vals, err := parser.ParseSeriesDesc(defLine)
if err != nil {
if perr, ok := err.(*parser.ParseErr); ok {
perr.lineOffset = i
perr.LineOffset = i
}
return i, nil, err
}
@ -151,8 +151,8 @@ func (t *Test) parseEval(lines []string, i int) (int, *evalCmd, error) {
_, err := parser.ParseExpr(expr)
if err != nil {
if perr, ok := err.(*parser.ParseErr); ok {
perr.lineOffset = i
posOffset := Pos(strings.Index(lines[i], expr))
perr.LineOffset = i
posOffset := parser.Pos(strings.Index(lines[i], expr))
perr.PositionRange.Start += posOffset
perr.PositionRange.End += posOffset
perr.Query = lines[i]
@ -160,7 +160,7 @@ func (t *Test) parseEval(lines []string, i int) (int, *evalCmd, error) {
return i, nil, err
}
offset, err := model.parser.ParseDuration(at)
offset, err := model.ParseDuration(at)
if err != nil {
return i, nil, raise(i, "invalid step definition %q: %s", parts[1], err)
}
@ -182,13 +182,13 @@ func (t *Test) parseEval(lines []string, i int) (int, *evalCmd, error) {
break
}
if f, err := parseNumber(defLine); err == nil {
cmd.expect(0, nil, parser.SequenceValue{value: f})
cmd.expect(0, nil, parser.SequenceValue{Value: f})
break
}
metric, vals, err := parseSeriesDesc(defLine)
metric, vals, err := parser.ParseSeriesDesc(defLine)
if err != nil {
if perr, ok := err.(*parser.ParseErr); ok {
perr.lineOffset = i
perr.LineOffset = i
}
return i, nil, err
}
@ -282,10 +282,10 @@ func (cmd *loadCmd) set(m labels.Labels, vals ...parser.SequenceValue) {
samples := make([]Point, 0, len(vals))
ts := testStartTime
for _, v := range vals {
if !v.omitted {
if !v.Omitted {
samples = append(samples, Point{
T: ts.UnixNano() / int64(time.Millisecond/time.Nanosecond),
V: v.value,
V: v.Value,
})
}
ts = ts.Add(cmd.gap)
@ -374,8 +374,8 @@ func (ev *evalCmd) compareResult(result parser.Value) error {
if ev.ordered && exp.pos != pos+1 {
return errors.Errorf("expected metric %s with %v at position %d but was at %d", v.Metric, exp.vals, exp.pos, pos+1)
}
if !almostEqual(exp.vals[0].value, v.V) {
return errors.Errorf("expected %v for %s but got %v", exp.vals[0].value, v.Metric, v.V)
if !almostEqual(exp.vals[0].Value, v.V) {
return errors.Errorf("expected %v for %s but got %v", exp.vals[0].Value, v.Metric, v.V)
}
seen[fp] = true
@ -391,8 +391,8 @@ func (ev *evalCmd) compareResult(result parser.Value) error {
}
case Scalar:
if !almostEqual(ev.expected[0].vals[0].value, val.V) {
return errors.Errorf("expected Scalar %v but got %v", val.V, ev.expected[0].vals[0].value)
if !almostEqual(ev.expected[0].vals[0].Value, val.V) {
return errors.Errorf("expected Scalar %v but got %v", val.V, ev.expected[0].vals[0].Value)
}
default:
@ -459,7 +459,7 @@ func (t *Test) exec(tc testCommand) error {
return errors.Errorf("expected error evaluating query %q (line %d) but got none", cmd.expr, cmd.line)
}
err = cmd.compareResult(res.parser.Value)
err = cmd.compareResult(res.Value)
if err != nil {
return errors.Wrapf(err, "error in %s %s", cmd, cmd.expr)
}
@ -479,7 +479,7 @@ func (t *Test) exec(tc testCommand) error {
// Ordering isn't defined for range queries.
return nil
}
mat := rangeRes.parser.Value.(Matrix)
mat := rangeRes.Value.(Matrix)
vec := make(Vector, 0, len(mat))
for _, series := range mat {
for _, point := range series.Points {
@ -489,7 +489,7 @@ func (t *Test) exec(tc testCommand) error {
}
}
}
if _, ok := res.parser.Value.(Scalar); ok {
if _, ok := res.Value.(Scalar); ok {
err = cmd.compareResult(Scalar{V: vec[0].Point.V})
} else {
err = cmd.compareResult(vec)
@ -559,10 +559,10 @@ func almostEqual(a, b float64) bool {
}
func parseNumber(s string) (float64, error) {
n, err := strconv.parser.ParseInt(s, 0, 64)
n, err := strconv.ParseInt(s, 0, 64)
f := float64(n)
if err != nil {
f, err = strconv.parser.ParseFloat(s, 64)
f, err = strconv.ParseFloat(s, 64)
}
if err != nil {
return 0, errors.Wrap(err, "error parsing number")

Write Preview
Loading…
Cancel
Save