mudhorn/prometheus
1
0
Fork 0
mirror of https://github.com/prometheus/prometheus.git synced 2024-12-26 22:19:40 -08:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity
prometheus/promql/parse_test.go

1818 lines
48 KiB
Go
Raw Normal View History

Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
// Copyright 2015 The Prometheus 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 promql
import (
"fmt"
"math"
"reflect"
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
"strings"
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
"testing"
"time"
Switch from client_golang/model to common/model
2015-08-20 08:18:46 -07:00
"github.com/prometheus/common/model"
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
"github.com/prometheus/prometheus/pkg/labels"
promql: misc fixes
2016-12-28 00:16:48 -08:00
"github.com/stretchr/testify/require"
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
)
var testExpr = []struct {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input string // The input to be parsed.
expected Expr // The expected expression AST.
fail bool // Whether parsing is supposed to fail.
errMsg string // If not empty the parsing error has to contain this string.
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}{
promql: misc fixes
2016-12-28 00:16:48 -08:00
// Scalars and scalar-to-scalar operations.
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
{
input: "1",
expected: &NumberLiteral{1},
}, {
input: "+Inf",
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
expected: &NumberLiteral{math.Inf(1)},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
input: "-Inf",
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
expected: &NumberLiteral{math.Inf(-1)},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
input: ".5",
expected: &NumberLiteral{0.5},
}, {
input: "5.",
expected: &NumberLiteral{5},
}, {
input: "123.4567",
expected: &NumberLiteral{123.4567},
}, {
input: "5e-3",
expected: &NumberLiteral{0.005},
}, {
input: "5e3",
expected: &NumberLiteral{5000},
}, {
input: "0xc",
expected: &NumberLiteral{12},
}, {
input: "0755",
expected: &NumberLiteral{493},
}, {
input: "+5.5e-3",
expected: &NumberLiteral{0.0055},
}, {
input: "-0755",
expected: &NumberLiteral{-493},
}, {
input: "1 + 1",
promql: Add 'bool' modifier to comparison functions When doing comparison operations on vectors, filtering sometimes gets in the way and you have to go to a fair bit of effort to workaround it in order to always return a result. The 'bool' modifier instead of filtering returns 0/1 depending on the result of the compairson. This is also a prerequisite to removing plain scalar/scalar comparisons, as it maintains the current behaviour under a new syntax.
2015-09-02 06:51:44 -07:00
expected: &BinaryExpr{itemADD, &NumberLiteral{1}, &NumberLiteral{1}, nil, false},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
input: "1 - 1",
promql: Add 'bool' modifier to comparison functions When doing comparison operations on vectors, filtering sometimes gets in the way and you have to go to a fair bit of effort to workaround it in order to always return a result. The 'bool' modifier instead of filtering returns 0/1 depending on the result of the compairson. This is also a prerequisite to removing plain scalar/scalar comparisons, as it maintains the current behaviour under a new syntax.
2015-09-02 06:51:44 -07:00
expected: &BinaryExpr{itemSUB, &NumberLiteral{1}, &NumberLiteral{1}, nil, false},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
input: "1 * 1",
promql: Add 'bool' modifier to comparison functions When doing comparison operations on vectors, filtering sometimes gets in the way and you have to go to a fair bit of effort to workaround it in order to always return a result. The 'bool' modifier instead of filtering returns 0/1 depending on the result of the compairson. This is also a prerequisite to removing plain scalar/scalar comparisons, as it maintains the current behaviour under a new syntax.
2015-09-02 06:51:44 -07:00
expected: &BinaryExpr{itemMUL, &NumberLiteral{1}, &NumberLiteral{1}, nil, false},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
input: "1 % 1",
promql: Add 'bool' modifier to comparison functions When doing comparison operations on vectors, filtering sometimes gets in the way and you have to go to a fair bit of effort to workaround it in order to always return a result. The 'bool' modifier instead of filtering returns 0/1 depending on the result of the compairson. This is also a prerequisite to removing plain scalar/scalar comparisons, as it maintains the current behaviour under a new syntax.
2015-09-02 06:51:44 -07:00
expected: &BinaryExpr{itemMOD, &NumberLiteral{1}, &NumberLiteral{1}, nil, false},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
input: "1 / 1",
promql: Add 'bool' modifier to comparison functions When doing comparison operations on vectors, filtering sometimes gets in the way and you have to go to a fair bit of effort to workaround it in order to always return a result. The 'bool' modifier instead of filtering returns 0/1 depending on the result of the compairson. This is also a prerequisite to removing plain scalar/scalar comparisons, as it maintains the current behaviour under a new syntax.
2015-09-02 06:51:44 -07:00
expected: &BinaryExpr{itemDIV, &NumberLiteral{1}, &NumberLiteral{1}, nil, false},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
promql: Remove scalar/scalar comparisons. This change is breaking, use the 'bool' modifier for such comprisons. After this change all comparisons without 'bool' will filter, and all comparisons with 'bool' will return 0/1. This makes the language more consistent and orthogonal, and ultimately easier to learn and use. If we ever figure out sane semantics for filtering scalar/scalar comparisons we can add them in, which will most likely come out of how the new vector() function is used.
2015-10-10 08:19:14 -07:00
input: "1 == bool 1",
expected: &BinaryExpr{itemEQL, &NumberLiteral{1}, &NumberLiteral{1}, nil, true},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
promql: Remove scalar/scalar comparisons. This change is breaking, use the 'bool' modifier for such comprisons. After this change all comparisons without 'bool' will filter, and all comparisons with 'bool' will return 0/1. This makes the language more consistent and orthogonal, and ultimately easier to learn and use. If we ever figure out sane semantics for filtering scalar/scalar comparisons we can add them in, which will most likely come out of how the new vector() function is used.
2015-10-10 08:19:14 -07:00
input: "1 != bool 1",
expected: &BinaryExpr{itemNEQ, &NumberLiteral{1}, &NumberLiteral{1}, nil, true},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
promql: Remove scalar/scalar comparisons. This change is breaking, use the 'bool' modifier for such comprisons. After this change all comparisons without 'bool' will filter, and all comparisons with 'bool' will return 0/1. This makes the language more consistent and orthogonal, and ultimately easier to learn and use. If we ever figure out sane semantics for filtering scalar/scalar comparisons we can add them in, which will most likely come out of how the new vector() function is used.
2015-10-10 08:19:14 -07:00
input: "1 > bool 1",
expected: &BinaryExpr{itemGTR, &NumberLiteral{1}, &NumberLiteral{1}, nil, true},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
promql: Remove scalar/scalar comparisons. This change is breaking, use the 'bool' modifier for such comprisons. After this change all comparisons without 'bool' will filter, and all comparisons with 'bool' will return 0/1. This makes the language more consistent and orthogonal, and ultimately easier to learn and use. If we ever figure out sane semantics for filtering scalar/scalar comparisons we can add them in, which will most likely come out of how the new vector() function is used.
2015-10-10 08:19:14 -07:00
input: "1 >= bool 1",
expected: &BinaryExpr{itemGTE, &NumberLiteral{1}, &NumberLiteral{1}, nil, true},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
promql: Remove scalar/scalar comparisons. This change is breaking, use the 'bool' modifier for such comprisons. After this change all comparisons without 'bool' will filter, and all comparisons with 'bool' will return 0/1. This makes the language more consistent and orthogonal, and ultimately easier to learn and use. If we ever figure out sane semantics for filtering scalar/scalar comparisons we can add them in, which will most likely come out of how the new vector() function is used.
2015-10-10 08:19:14 -07:00
input: "1 < bool 1",
expected: &BinaryExpr{itemLSS, &NumberLiteral{1}, &NumberLiteral{1}, nil, true},
promql: Add 'bool' modifier to comparison functions When doing comparison operations on vectors, filtering sometimes gets in the way and you have to go to a fair bit of effort to workaround it in order to always return a result. The 'bool' modifier instead of filtering returns 0/1 depending on the result of the compairson. This is also a prerequisite to removing plain scalar/scalar comparisons, as it maintains the current behaviour under a new syntax.
2015-09-02 06:51:44 -07:00
}, {
input: "1 <= bool 1",
expected: &BinaryExpr{itemLTE, &NumberLiteral{1}, &NumberLiteral{1}, nil, true},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
input: "+1 + -2 * 1",
expected: &BinaryExpr{
Op: itemADD,
LHS: &NumberLiteral{1},
RHS: &BinaryExpr{
Op: itemMUL, LHS: &NumberLiteral{-2}, RHS: &NumberLiteral{1},
},
},
}, {
input: "1 + 2/(3*1)",
expected: &BinaryExpr{
Op: itemADD,
LHS: &NumberLiteral{1},
RHS: &BinaryExpr{
Op: itemDIV,
LHS: &NumberLiteral{2},
RHS: &ParenExpr{&BinaryExpr{
Op: itemMUL, LHS: &NumberLiteral{3}, RHS: &NumberLiteral{1},
}},
},
},
rewrite operator balancing to be recursive
2016-03-02 15:56:40 -08:00
}, {
input: "1 < bool 2 - 1 * 2",
expected: &BinaryExpr{
Op: itemLSS,
ReturnBool: true,
LHS: &NumberLiteral{1},
RHS: &BinaryExpr{
Op: itemSUB,
LHS: &NumberLiteral{2},
RHS: &BinaryExpr{
Op: itemMUL, LHS: &NumberLiteral{1}, RHS: &NumberLiteral{2},
},
},
},
Implement unary expression for vector types. Closes #956
2015-08-04 05:57:34 -07:00
}, {
Parser test cleanup (#3977) * parser test cleanup - Test against the exported package functions instead of the private functions. * Improves readability of TestParseSeries - Moves package function closer to parser function
2018-03-20 07:30:52 -07:00
input: "-some_metric",
expected: &UnaryExpr{
Implement unary expression for vector types. Closes #956
2015-08-04 05:57:34 -07:00
Op: itemSUB,
Expr: &VectorSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Implement unary expression for vector types. Closes #956
2015-08-04 05:57:34 -07:00
},
},
},
}, {
Parser test cleanup (#3977) * parser test cleanup - Test against the exported package functions instead of the private functions. * Improves readability of TestParseSeries - Moves package function closer to parser function
2018-03-20 07:30:52 -07:00
input: "+some_metric",
expected: &UnaryExpr{
Implement unary expression for vector types. Closes #956
2015-08-04 05:57:34 -07:00
Op: itemADD,
Expr: &VectorSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Implement unary expression for vector types. Closes #956
2015-08-04 05:57:34 -07:00
},
},
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "",
fail: true,
errMsg: "no expression found in input",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "# just a comment\n\n",
fail: true,
errMsg: "no expression found in input",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "1+",
fail: true,
Add missing check for nil expression
2015-08-03 03:28:40 -07:00
errMsg: "no valid expression found",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: ".",
fail: true,
errMsg: "unexpected character: '.'",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "2.5.",
fail: true,
errMsg: "could not parse remaining input \".\"...",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "100..4",
fail: true,
errMsg: "could not parse remaining input \".4\"...",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "0deadbeef",
fail: true,
errMsg: "bad number or duration syntax: \"0de\"",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "1 /",
fail: true,
Add missing check for nil expression
2015-08-03 03:28:40 -07:00
errMsg: "no valid expression found",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "*1",
fail: true,
errMsg: "no valid expression found",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "(1))",
fail: true,
errMsg: "could not parse remaining input \")\"...",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "((1)",
fail: true,
errMsg: "unclosed left parenthesis",
Migrate parsing error tests. The promql_test checks failure of various bad syntaxed queries. Those are moved into the parser tests as the new testing language only deals with valid queries.
2015-05-12 03:00:28 -07:00
}, {
input: "999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999",
fail: true,
errMsg: "out of range",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "(",
fail: true,
errMsg: "unclosed left parenthesis",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "1 and 1",
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "set operator \"and\" not allowed in binary scalar expression",
promql: Remove scalar/scalar comparisons. This change is breaking, use the 'bool' modifier for such comprisons. After this change all comparisons without 'bool' will filter, and all comparisons with 'bool' will return 0/1. This makes the language more consistent and orthogonal, and ultimately easier to learn and use. If we ever figure out sane semantics for filtering scalar/scalar comparisons we can add them in, which will most likely come out of how the new vector() function is used.
2015-10-10 08:19:14 -07:00
}, {
input: "1 == 1",
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "parse error at char 7: comparisons between scalars must use BOOL modifier",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "1 or 1",
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "set operator \"or\" not allowed in binary scalar expression",
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
}, {
input: "1 unless 1",
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "set operator \"unless\" not allowed in binary scalar expression",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "1 !~ 1",
fail: true,
errMsg: "could not parse remaining input \"!~ 1\"...",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "1 =~ 1",
fail: true,
errMsg: "could not parse remaining input \"=~ 1\"...",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Implement unary expression for vector types. Closes #956
2015-08-04 05:57:34 -07:00
input: `-"string"`,
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: `unary expression only allowed on expressions of type scalar or instant vector, got "string"`,
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
}, {
Implement unary expression for vector types. Closes #956
2015-08-04 05:57:34 -07:00
input: `-test[5m]`,
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: `unary expression only allowed on expressions of type scalar or instant vector, got "range vector"`,
Implement unary expression for vector types. Closes #956
2015-08-04 05:57:34 -07:00
}, {
input: `*test`,
fail: true,
errMsg: "no valid expression found",
Rename matrix to range selector in external error messages The documentation speaks about range vectors and range vector selectors. This change does not fix all issues, we might still expose the term "Matrix" in error messages using %T.
2016-01-25 10:22:37 -08:00
}, {
input: "1 offset 1d",
fail: true,
errMsg: "offset modifier must be preceded by an instant or range selector",
Add 'ignoring' as modifier for binops. Where 'on' uses the given labels to match, 'ignoring' uses all other labels to match. group_left/right is not supported yet.
2016-04-21 03:45:06 -07:00
}, {
Add support for OneToMany with IGNORING. The labels listed in the group_ modifier will be copied from the one side to the many side. It will be valid to specify no labels. This is intended to replace the existing ON/GROUP_* support.,
2016-04-21 07:53:14 -07:00
input: "a - on(b) ignoring(c) d",
Add 'ignoring' as modifier for binops. Where 'on' uses the given labels to match, 'ignoring' uses all other labels to match. group_left/right is not supported yet.
2016-04-21 03:45:06 -07:00
fail: true,
Add support for OneToMany with IGNORING. The labels listed in the group_ modifier will be copied from the one side to the many side. It will be valid to specify no labels. This is intended to replace the existing ON/GROUP_* support.,
2016-04-21 07:53:14 -07:00
errMsg: "parse error at char 11: no valid expression found",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
// Vector binary operations.
{
input: "foo * bar",
expected: &BinaryExpr{
Op: itemMUL,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
VectorMatching: &VectorMatching{Card: CardOneToOne},
},
}, {
input: "foo == 1",
expected: &BinaryExpr{
Op: itemEQL,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
RHS: &NumberLiteral{1},
},
promql: Add 'bool' modifier to comparison functions When doing comparison operations on vectors, filtering sometimes gets in the way and you have to go to a fair bit of effort to workaround it in order to always return a result. The 'bool' modifier instead of filtering returns 0/1 depending on the result of the compairson. This is also a prerequisite to removing plain scalar/scalar comparisons, as it maintains the current behaviour under a new syntax.
2015-09-02 06:51:44 -07:00
}, {
input: "foo == bool 1",
expected: &BinaryExpr{
Op: itemEQL,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
promql: Add 'bool' modifier to comparison functions When doing comparison operations on vectors, filtering sometimes gets in the way and you have to go to a fair bit of effort to workaround it in order to always return a result. The 'bool' modifier instead of filtering returns 0/1 depending on the result of the compairson. This is also a prerequisite to removing plain scalar/scalar comparisons, as it maintains the current behaviour under a new syntax.
2015-09-02 06:51:44 -07:00
},
},
RHS: &NumberLiteral{1},
ReturnBool: true,
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
input: "2.5 / bar",
expected: &BinaryExpr{
Op: itemDIV,
LHS: &NumberLiteral{2.5},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
},
}, {
input: "foo and bar",
expected: &BinaryExpr{
Op: itemLAND,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
VectorMatching: &VectorMatching{Card: CardManyToMany},
},
}, {
input: "foo or bar",
expected: &BinaryExpr{
Op: itemLOR,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
VectorMatching: &VectorMatching{Card: CardManyToMany},
},
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
}, {
input: "foo unless bar",
expected: &BinaryExpr{
Op: itemLUnless,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
},
},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
},
},
VectorMatching: &VectorMatching{Card: CardManyToMany},
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
// Test and/or precedence and reassigning of operands.
input: "foo + bar or bla and blub",
expected: &BinaryExpr{
Op: itemLOR,
LHS: &BinaryExpr{
Op: itemADD,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
VectorMatching: &VectorMatching{Card: CardOneToOne},
},
RHS: &BinaryExpr{
Op: itemLAND,
LHS: &VectorSelector{
Name: "bla",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bla"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
RHS: &VectorSelector{
Name: "blub",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "blub"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
VectorMatching: &VectorMatching{Card: CardManyToMany},
},
VectorMatching: &VectorMatching{Card: CardManyToMany},
},
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
}, {
// Test and/or/unless precedence.
input: "foo and bar unless baz or qux",
expected: &BinaryExpr{
Op: itemLOR,
LHS: &BinaryExpr{
Op: itemLUnless,
LHS: &BinaryExpr{
Op: itemLAND,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
},
},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
},
},
VectorMatching: &VectorMatching{Card: CardManyToMany},
},
RHS: &VectorSelector{
Name: "baz",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "baz"),
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
},
},
VectorMatching: &VectorMatching{Card: CardManyToMany},
},
RHS: &VectorSelector{
Name: "qux",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "qux"),
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
},
},
VectorMatching: &VectorMatching{Card: CardManyToMany},
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
// Test precedence and reassigning of operands.
input: "bar + on(foo) bla / on(baz, buz) group_right(test) blub",
expected: &BinaryExpr{
Op: itemADD,
LHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
RHS: &BinaryExpr{
Op: itemDIV,
LHS: &VectorSelector{
Name: "bla",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bla"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
RHS: &VectorSelector{
Name: "blub",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "blub"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
VectorMatching: &VectorMatching{
Rename On to MatchingLabels
2016-04-26 06:28:36 -07:00
Card: CardOneToMany,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
MatchingLabels: []string{"baz", "buz"},
Flip vector matching to be ignoring by default. This is a noop semantically.
2016-06-23 09:23:44 -07:00
On: true,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
Include: []string{"test"},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
VectorMatching: &VectorMatching{
Rename On to MatchingLabels
2016-04-26 06:28:36 -07:00
Card: CardOneToOne,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
MatchingLabels: []string{"foo"},
Flip vector matching to be ignoring by default. This is a noop semantically.
2016-06-23 09:23:44 -07:00
On: true,
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
}, {
input: "foo * on(test,blub) bar",
expected: &BinaryExpr{
Op: itemMUL,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
VectorMatching: &VectorMatching{
Rename On to MatchingLabels
2016-04-26 06:28:36 -07:00
Card: CardOneToOne,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
MatchingLabels: []string{"test", "blub"},
Flip vector matching to be ignoring by default. This is a noop semantically.
2016-06-23 09:23:44 -07:00
On: true,
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
For many-to-one matches, always copy label from one side. This is a breaking change for everyone using the machine roles labeling approach.
2016-04-21 11:03:10 -07:00
}, {
input: "foo * on(test,blub) group_left bar",
expected: &BinaryExpr{
Op: itemMUL,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
For many-to-one matches, always copy label from one side. This is a breaking change for everyone using the machine roles labeling approach.
2016-04-21 11:03:10 -07:00
},
},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
For many-to-one matches, always copy label from one side. This is a breaking change for everyone using the machine roles labeling approach.
2016-04-21 11:03:10 -07:00
},
},
VectorMatching: &VectorMatching{
Rename On to MatchingLabels
2016-04-26 06:28:36 -07:00
Card: CardManyToOne,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
MatchingLabels: []string{"test", "blub"},
Flip vector matching to be ignoring by default. This is a noop semantically.
2016-06-23 09:23:44 -07:00
On: true,
For many-to-one matches, always copy label from one side. This is a breaking change for everyone using the machine roles labeling approach.
2016-04-21 11:03:10 -07:00
},
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
input: "foo and on(test,blub) bar",
expected: &BinaryExpr{
Op: itemLAND,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
VectorMatching: &VectorMatching{
Rename On to MatchingLabels
2016-04-26 06:28:36 -07:00
Card: CardManyToMany,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
MatchingLabels: []string{"test", "blub"},
Flip vector matching to be ignoring by default. This is a noop semantically.
2016-06-23 09:23:44 -07:00
On: true,
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
Allow on, ignoring, by and without wit empty laberls. This offers new semantics in allowing on() for matching two single-element vectors with no known common labels. Previosuly this was often done using on(dummy). This also allows making it explict that you meant to do an aggregation without labels via by(). Fixes #1597.
2016-06-23 09:49:22 -07:00
}, {
input: "foo and on() bar",
expected: &BinaryExpr{
Op: itemLAND,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Allow on, ignoring, by and without wit empty laberls. This offers new semantics in allowing on() for matching two single-element vectors with no known common labels. Previosuly this was often done using on(dummy). This also allows making it explict that you meant to do an aggregation without labels via by(). Fixes #1597.
2016-06-23 09:49:22 -07:00
},
},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Allow on, ignoring, by and without wit empty laberls. This offers new semantics in allowing on() for matching two single-element vectors with no known common labels. Previosuly this was often done using on(dummy). This also allows making it explict that you meant to do an aggregation without labels via by(). Fixes #1597.
2016-06-23 09:49:22 -07:00
},
},
VectorMatching: &VectorMatching{
Card: CardManyToMany,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
MatchingLabels: []string{},
Allow on, ignoring, by and without wit empty laberls. This offers new semantics in allowing on() for matching two single-element vectors with no known common labels. Previosuly this was often done using on(dummy). This also allows making it explict that you meant to do an aggregation without labels via by(). Fixes #1597.
2016-06-23 09:49:22 -07:00
On: true,
},
},
Add 'ignoring' as modifier for binops. Where 'on' uses the given labels to match, 'ignoring' uses all other labels to match. group_left/right is not supported yet.
2016-04-21 03:45:06 -07:00
}, {
input: "foo and ignoring(test,blub) bar",
expected: &BinaryExpr{
Op: itemLAND,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Add 'ignoring' as modifier for binops. Where 'on' uses the given labels to match, 'ignoring' uses all other labels to match. group_left/right is not supported yet.
2016-04-21 03:45:06 -07:00
},
},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Add 'ignoring' as modifier for binops. Where 'on' uses the given labels to match, 'ignoring' uses all other labels to match. group_left/right is not supported yet.
2016-04-21 03:45:06 -07:00
},
},
VectorMatching: &VectorMatching{
Rename On to MatchingLabels
2016-04-26 06:28:36 -07:00
Card: CardManyToMany,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
MatchingLabels: []string{"test", "blub"},
Add 'ignoring' as modifier for binops. Where 'on' uses the given labels to match, 'ignoring' uses all other labels to match. group_left/right is not supported yet.
2016-04-21 03:45:06 -07:00
},
},
Allow on, ignoring, by and without wit empty laberls. This offers new semantics in allowing on() for matching two single-element vectors with no known common labels. Previosuly this was often done using on(dummy). This also allows making it explict that you meant to do an aggregation without labels via by(). Fixes #1597.
2016-06-23 09:49:22 -07:00
}, {
input: "foo and ignoring() bar",
expected: &BinaryExpr{
Op: itemLAND,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Allow on, ignoring, by and without wit empty laberls. This offers new semantics in allowing on() for matching two single-element vectors with no known common labels. Previosuly this was often done using on(dummy). This also allows making it explict that you meant to do an aggregation without labels via by(). Fixes #1597.
2016-06-23 09:49:22 -07:00
},
},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Allow on, ignoring, by and without wit empty laberls. This offers new semantics in allowing on() for matching two single-element vectors with no known common labels. Previosuly this was often done using on(dummy). This also allows making it explict that you meant to do an aggregation without labels via by(). Fixes #1597.
2016-06-23 09:49:22 -07:00
},
},
VectorMatching: &VectorMatching{
Card: CardManyToMany,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
MatchingLabels: []string{},
Allow on, ignoring, by and without wit empty laberls. This offers new semantics in allowing on() for matching two single-element vectors with no known common labels. Previosuly this was often done using on(dummy). This also allows making it explict that you meant to do an aggregation without labels via by(). Fixes #1597.
2016-06-23 09:49:22 -07:00
},
},
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
}, {
input: "foo unless on(bar) baz",
expected: &BinaryExpr{
Op: itemLUnless,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
},
},
RHS: &VectorSelector{
Name: "baz",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "baz"),
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
},
},
VectorMatching: &VectorMatching{
Rename On to MatchingLabels
2016-04-26 06:28:36 -07:00
Card: CardManyToMany,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
MatchingLabels: []string{"bar"},
Flip vector matching to be ignoring by default. This is a noop semantically.
2016-06-23 09:23:44 -07:00
On: true,
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
},
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
input: "foo / on(test,blub) group_left(bar) bar",
expected: &BinaryExpr{
Op: itemDIV,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
VectorMatching: &VectorMatching{
Rename On to MatchingLabels
2016-04-26 06:28:36 -07:00
Card: CardManyToOne,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
MatchingLabels: []string{"test", "blub"},
Flip vector matching to be ignoring by default. This is a noop semantically.
2016-06-23 09:23:44 -07:00
On: true,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
Include: []string{"bar"},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
Add support for OneToMany with IGNORING. The labels listed in the group_ modifier will be copied from the one side to the many side. It will be valid to specify no labels. This is intended to replace the existing ON/GROUP_* support.,
2016-04-21 07:53:14 -07:00
}, {
input: "foo / ignoring(test,blub) group_left(blub) bar",
expected: &BinaryExpr{
Op: itemDIV,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Add support for OneToMany with IGNORING. The labels listed in the group_ modifier will be copied from the one side to the many side. It will be valid to specify no labels. This is intended to replace the existing ON/GROUP_* support.,
2016-04-21 07:53:14 -07:00
},
},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Add support for OneToMany with IGNORING. The labels listed in the group_ modifier will be copied from the one side to the many side. It will be valid to specify no labels. This is intended to replace the existing ON/GROUP_* support.,
2016-04-21 07:53:14 -07:00
},
},
VectorMatching: &VectorMatching{
Rename On to MatchingLabels
2016-04-26 06:28:36 -07:00
Card: CardManyToOne,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
MatchingLabels: []string{"test", "blub"},
Include: []string{"blub"},
Add support for OneToMany with IGNORING. The labels listed in the group_ modifier will be copied from the one side to the many side. It will be valid to specify no labels. This is intended to replace the existing ON/GROUP_* support.,
2016-04-21 07:53:14 -07:00
},
},
}, {
input: "foo / ignoring(test,blub) group_left(bar) bar",
expected: &BinaryExpr{
Op: itemDIV,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Add support for OneToMany with IGNORING. The labels listed in the group_ modifier will be copied from the one side to the many side. It will be valid to specify no labels. This is intended to replace the existing ON/GROUP_* support.,
2016-04-21 07:53:14 -07:00
},
},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Add support for OneToMany with IGNORING. The labels listed in the group_ modifier will be copied from the one side to the many side. It will be valid to specify no labels. This is intended to replace the existing ON/GROUP_* support.,
2016-04-21 07:53:14 -07:00
},
},
VectorMatching: &VectorMatching{
Rename On to MatchingLabels
2016-04-26 06:28:36 -07:00
Card: CardManyToOne,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
MatchingLabels: []string{"test", "blub"},
Include: []string{"bar"},
Add support for OneToMany with IGNORING. The labels listed in the group_ modifier will be copied from the one side to the many side. It will be valid to specify no labels. This is intended to replace the existing ON/GROUP_* support.,
2016-04-21 07:53:14 -07:00
},
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
input: "foo - on(test,blub) group_right(bar,foo) bar",
expected: &BinaryExpr{
Op: itemSUB,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
VectorMatching: &VectorMatching{
Rename On to MatchingLabels
2016-04-26 06:28:36 -07:00
Card: CardOneToMany,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
MatchingLabels: []string{"test", "blub"},
Include: []string{"bar", "foo"},
Flip vector matching to be ignoring by default. This is a noop semantically.
2016-06-23 09:23:44 -07:00
On: true,
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
Add support for OneToMany with IGNORING. The labels listed in the group_ modifier will be copied from the one side to the many side. It will be valid to specify no labels. This is intended to replace the existing ON/GROUP_* support.,
2016-04-21 07:53:14 -07:00
}, {
input: "foo - ignoring(test,blub) group_right(bar,foo) bar",
expected: &BinaryExpr{
Op: itemSUB,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Add support for OneToMany with IGNORING. The labels listed in the group_ modifier will be copied from the one side to the many side. It will be valid to specify no labels. This is intended to replace the existing ON/GROUP_* support.,
2016-04-21 07:53:14 -07:00
},
},
RHS: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Add support for OneToMany with IGNORING. The labels listed in the group_ modifier will be copied from the one side to the many side. It will be valid to specify no labels. This is intended to replace the existing ON/GROUP_* support.,
2016-04-21 07:53:14 -07:00
},
},
VectorMatching: &VectorMatching{
Rename On to MatchingLabels
2016-04-26 06:28:36 -07:00
Card: CardOneToMany,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
MatchingLabels: []string{"test", "blub"},
Include: []string{"bar", "foo"},
Add support for OneToMany with IGNORING. The labels listed in the group_ modifier will be copied from the one side to the many side. It will be valid to specify no labels. This is intended to replace the existing ON/GROUP_* support.,
2016-04-21 07:53:14 -07:00
},
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "foo and 1",
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "set operator \"and\" not allowed in binary scalar expression",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "1 and foo",
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "set operator \"and\" not allowed in binary scalar expression",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "foo or 1",
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "set operator \"or\" not allowed in binary scalar expression",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "1 or foo",
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "set operator \"or\" not allowed in binary scalar expression",
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
}, {
input: "foo unless 1",
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "set operator \"unless\" not allowed in binary scalar expression",
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
}, {
input: "1 unless foo",
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "set operator \"unless\" not allowed in binary scalar expression",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "1 or on(bar) foo",
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "vector matching only allowed between instant vectors",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "foo == on(bar) 10",
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "vector matching only allowed between instant vectors",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "foo and on(bar) group_left(baz) bar",
fail: true,
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
errMsg: "no grouping allowed for \"and\" operation",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "foo and on(bar) group_right(baz) bar",
fail: true,
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
errMsg: "no grouping allowed for \"and\" operation",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "foo or on(bar) group_left(baz) bar",
fail: true,
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
errMsg: "no grouping allowed for \"or\" operation",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "foo or on(bar) group_right(baz) bar",
fail: true,
Implement relative complement set operator "unless" The `unless` set operator can be used to return all vector elements from the LHS which do not match the elements on the RHS. A use case is to return all metrics for nodes which do not have a specific role: node_load1 unless on(instance) chef_role{role="app"}
2016-04-02 15:52:18 -07:00
errMsg: "no grouping allowed for \"or\" operation",
}, {
input: "foo unless on(bar) group_left(baz) bar",
fail: true,
errMsg: "no grouping allowed for \"unless\" operation",
}, {
input: "foo unless on(bar) group_right(baz) bar",
fail: true,
errMsg: "no grouping allowed for \"unless\" operation",
Migrate parsing error tests. The promql_test checks failure of various bad syntaxed queries. Those are moved into the parser tests as the new testing language only deals with valid queries.
2015-05-12 03:00:28 -07:00
}, {
input: `http_requests{group="production"} + on(instance) group_left(job,instance) cpu_count{type="smp"}`,
fail: true,
Clarify error message around on(x) group_left(x)
2016-04-26 06:31:00 -07:00
errMsg: "label \"instance\" must not occur in ON and GROUP clause at once",
promql: Add 'bool' modifier to comparison functions When doing comparison operations on vectors, filtering sometimes gets in the way and you have to go to a fair bit of effort to workaround it in order to always return a result. The 'bool' modifier instead of filtering returns 0/1 depending on the result of the compairson. This is also a prerequisite to removing plain scalar/scalar comparisons, as it maintains the current behaviour under a new syntax.
2015-09-02 06:51:44 -07:00
}, {
input: "foo + bool bar",
fail: true,
errMsg: "bool modifier can only be used on comparison operators",
}, {
input: "foo + bool 10",
fail: true,
errMsg: "bool modifier can only be used on comparison operators",
}, {
input: "foo and bool 10",
fail: true,
errMsg: "bool modifier can only be used on comparison operators",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
promql: rename vector
2016-12-24 01:40:09 -08:00
// Test Vector selector.
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
{
input: "foo",
expected: &VectorSelector{
Name: "foo",
Offset: 0,
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
}, {
input: "foo offset 5m",
expected: &VectorSelector{
Name: "foo",
Offset: 5 * time.Minute,
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
}, {
Fix single quote parsing, add tests
2015-05-08 07:43:02 -07:00
input: `foo:bar{a="bc"}`,
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
expected: &VectorSelector{
Name: "foo:bar",
Offset: 0,
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, "a", "bc"),
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo:bar"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
}, {
Fix single quote parsing, add tests
2015-05-08 07:43:02 -07:00
input: `foo{NaN='bc'}`,
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
expected: &VectorSelector{
Name: "foo",
Offset: 0,
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, "NaN", "bc"),
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
}, {
input: `foo{a="b", foo!="bar", test=~"test", bar!~"baz"}`,
expected: &VectorSelector{
Name: "foo",
Offset: 0,
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, "a", "b"),
mustLabelMatcher(labels.MatchNotEqual, "foo", "bar"),
mustLabelMatcher(labels.MatchRegexp, "test", "test"),
mustLabelMatcher(labels.MatchNotRegexp, "bar", "baz"),
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `{`,
fail: true,
errMsg: "unexpected end of input inside braces",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `}`,
fail: true,
errMsg: "unexpected character: '}'",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `some{`,
fail: true,
errMsg: "unexpected end of input inside braces",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `some}`,
fail: true,
errMsg: "could not parse remaining input \"}\"...",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `some_metric{a=b}`,
fail: true,
errMsg: "unexpected identifier \"b\" in label matching, expected string",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `some_metric{a:b="b"}`,
fail: true,
errMsg: "unexpected character inside braces: ':'",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `foo{a*"b"}`,
fail: true,
errMsg: "unexpected character inside braces: '*'",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `foo{a>="b"}`,
fail: true,
// TODO(fabxc): willingly lexing wrong tokens allows for more precrise error
// messages from the parser - consider if this is an option.
errMsg: "unexpected character inside braces: '>'",
Check for invalid utf-8 in lexer strings. This protects against invalid utf-8 sneaking in via label_replace.
2017-06-16 07:19:24 -07:00
}, {
input: "some_metric{a=\"\xff\"}",
fail: true,
errMsg: "parse error at char 15: invalid UTF-8 rune",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `foo{gibberish}`,
fail: true,
errMsg: "expected label matching operator but got }",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `foo{1}`,
fail: true,
errMsg: "unexpected character inside braces: '1'",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `{}`,
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "vector selector must contain label matchers or metric name",
promql: error if all label matchers are empty.
2015-06-15 09:34:41 -07:00
}, {
input: `{x=""}`,
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "vector selector must contain at least one non-empty matcher",
promql: error if all label matchers are empty.
2015-06-15 09:34:41 -07:00
}, {
input: `{x=~".*"}`,
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "vector selector must contain at least one non-empty matcher",
promql: error if all label matchers are empty.
2015-06-15 09:34:41 -07:00
}, {
input: `{x!~".+"}`,
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "vector selector must contain at least one non-empty matcher",
promql: error if all label matchers are empty.
2015-06-15 09:34:41 -07:00
}, {
input: `{x!="a"}`,
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "vector selector must contain at least one non-empty matcher",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `foo{__name__="bar"}`,
fail: true,
errMsg: "metric name must not be set twice: \"foo\" or \"bar\"",
// }, {
// input: `:foo`,
// fail: true,
// errMsg: "bla",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
// Test matrix selector.
{
input: "test[5s]",
expected: &MatrixSelector{
Name: "test",
Offset: 0,
Range: 5 * time.Second,
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "test"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
}, {
input: "test[5m]",
expected: &MatrixSelector{
Name: "test",
Offset: 0,
Range: 5 * time.Minute,
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "test"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
}, {
input: "test[5h] OFFSET 5m",
expected: &MatrixSelector{
Name: "test",
Offset: 5 * time.Minute,
Range: 5 * time.Hour,
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "test"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
}, {
input: "test[5d] OFFSET 10s",
expected: &MatrixSelector{
Name: "test",
Offset: 10 * time.Second,
Range: 5 * 24 * time.Hour,
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "test"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
}, {
input: "test[5w] offset 2w",
expected: &MatrixSelector{
Name: "test",
Offset: 14 * 24 * time.Hour,
Range: 5 * 7 * 24 * time.Hour,
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "test"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
}, {
input: `test{a="b"}[5y] OFFSET 3d`,
expected: &MatrixSelector{
Name: "test",
Offset: 3 * 24 * time.Hour,
Range: 5 * 365 * 24 * time.Hour,
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, "a", "b"),
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "test"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `foo[5mm]`,
fail: true,
errMsg: "bad duration syntax: \"5mm\"",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `foo[0m]`,
fail: true,
errMsg: "duration must be greater than 0",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `foo[5m30s]`,
fail: true,
errMsg: "bad duration syntax: \"5m3\"",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `foo[5m] OFFSET 1h30m`,
fail: true,
errMsg: "bad number or duration syntax: \"1h3\"",
Migrate parsing error tests. The promql_test checks failure of various bad syntaxed queries. Those are moved into the parser tests as the new testing language only deals with valid queries.
2015-05-12 03:00:28 -07:00
}, {
input: `foo["5m"]`,
fail: true,
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `foo[]`,
fail: true,
errMsg: "missing unit character in duration",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `foo[1]`,
fail: true,
errMsg: "missing unit character in duration",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `some_metric[5m] OFFSET 1`,
fail: true,
Consolidate offset modifier parsing Remove duplicated offset modifier parsing and ensure offset can only appear at the end of a selector statement.
2016-01-24 19:50:46 -08:00
errMsg: "unexpected number \"1\" in offset, expected duration",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `some_metric[5m] OFFSET 1mm`,
fail: true,
errMsg: "bad number or duration syntax: \"1mm\"",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `some_metric[5m] OFFSET`,
fail: true,
Consolidate offset modifier parsing Remove duplicated offset modifier parsing and ensure offset can only appear at the end of a selector statement.
2016-01-24 19:50:46 -08:00
errMsg: "unexpected end of input in offset, expected duration",
}, {
input: `some_metric OFFSET 1m[5m]`,
fail: true,
errMsg: "could not parse remaining input \"[5m]\"...",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `(foo + bar)[5m]`,
fail: true,
errMsg: "could not parse remaining input \"[5m]\"...",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
// Test aggregation.
{
input: "sum by (foo)(some_metric)",
expected: &AggregateExpr{
Op: itemSum,
Expr: &VectorSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
Grouping: []string{"foo"},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
}, {
input: "avg by (foo)(some_metric)",
expected: &AggregateExpr{
Op: itemAvg,
Expr: &VectorSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
Grouping: []string{"foo"},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
}, {
input: "max by (foo)(some_metric)",
expected: &AggregateExpr{
Op: itemMax,
Expr: &VectorSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
Grouping: []string{"foo"},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
Add without aggregator modifier. This has the advantage that the user doesn't need to list all labels they want to keep (as with "by") but without having to worry about inconsistent labels as when there's only one time series (as with "keeping_common"). Almost all aggregation should use this rather than the existing two options as it's much less error prone and easier to maintain due to not having to always add in "job" plus whatever other common job-level labels you have like "region".
2016-02-07 10:03:16 -08:00
}, {
input: "sum without (foo) (some_metric)",
expected: &AggregateExpr{
Op: itemSum,
Without: true,
Expr: &VectorSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Add without aggregator modifier. This has the advantage that the user doesn't need to list all labels they want to keep (as with "by") but without having to worry about inconsistent labels as when there's only one time series (as with "keeping_common"). Almost all aggregation should use this rather than the existing two options as it's much less error prone and easier to maintain due to not having to always add in "job" plus whatever other common job-level labels you have like "region".
2016-02-07 10:03:16 -08:00
},
},
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
Grouping: []string{"foo"},
Add without aggregator modifier. This has the advantage that the user doesn't need to list all labels they want to keep (as with "by") but without having to worry about inconsistent labels as when there's only one time series (as with "keeping_common"). Almost all aggregation should use this rather than the existing two options as it's much less error prone and easier to maintain due to not having to always add in "job" plus whatever other common job-level labels you have like "region".
2016-02-07 10:03:16 -08:00
},
}, {
input: "sum (some_metric) without (foo)",
expected: &AggregateExpr{
Op: itemSum,
Without: true,
Expr: &VectorSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Add without aggregator modifier. This has the advantage that the user doesn't need to list all labels they want to keep (as with "by") but without having to worry about inconsistent labels as when there's only one time series (as with "keeping_common"). Almost all aggregation should use this rather than the existing two options as it's much less error prone and easier to maintain due to not having to always add in "job" plus whatever other common job-level labels you have like "region".
2016-02-07 10:03:16 -08:00
},
},
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
Grouping: []string{"foo"},
Add without aggregator modifier. This has the advantage that the user doesn't need to list all labels they want to keep (as with "by") but without having to worry about inconsistent labels as when there's only one time series (as with "keeping_common"). Almost all aggregation should use this rather than the existing two options as it's much less error prone and easier to maintain due to not having to always add in "job" plus whatever other common job-level labels you have like "region".
2016-02-07 10:03:16 -08:00
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
input: "stddev(some_metric)",
expected: &AggregateExpr{
Op: itemStddev,
Expr: &VectorSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
},
}, {
input: "stdvar by (foo)(some_metric)",
expected: &AggregateExpr{
Op: itemStdvar,
Expr: &VectorSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
Grouping: []string{"foo"},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
Allow on, ignoring, by and without wit empty laberls. This offers new semantics in allowing on() for matching two single-element vectors with no known common labels. Previosuly this was often done using on(dummy). This also allows making it explict that you meant to do an aggregation without labels via by(). Fixes #1597.
2016-06-23 09:49:22 -07:00
}, {
input: "sum by ()(some_metric)",
expected: &AggregateExpr{
Op: itemSum,
Expr: &VectorSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Allow on, ignoring, by and without wit empty laberls. This offers new semantics in allowing on() for matching two single-element vectors with no known common labels. Previosuly this was often done using on(dummy). This also allows making it explict that you meant to do an aggregation without labels via by(). Fixes #1597.
2016-06-23 09:49:22 -07:00
},
},
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
Grouping: []string{},
Allow on, ignoring, by and without wit empty laberls. This offers new semantics in allowing on() for matching two single-element vectors with no known common labels. Previosuly this was often done using on(dummy). This also allows making it explict that you meant to do an aggregation without labels via by(). Fixes #1597.
2016-06-23 09:49:22 -07:00
},
Make topk/bottomk aggregators.
2016-07-04 05:10:42 -07:00
}, {
input: "topk(5, some_metric)",
expected: &AggregateExpr{
Op: itemTopK,
Expr: &VectorSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Make topk/bottomk aggregators.
2016-07-04 05:10:42 -07:00
},
},
Param: &NumberLiteral{5},
},
Add count_values() aggregator. This is useful for counting how many instances of a job are running a particular version/build. Fixes #622
2016-07-05 09:12:19 -07:00
}, {
input: "count_values(\"value\", some_metric)",
expected: &AggregateExpr{
Op: itemCountValues,
Expr: &VectorSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Add count_values() aggregator. This is useful for counting how many instances of a job are running a particular version/build. Fixes #622
2016-07-05 09:12:19 -07:00
},
},
Param: &StringLiteral{"value"},
},
Fix parsing of label names which are also keywords The current separation between lexer and parser is a bit fuzzy when it comes to operators, aggregators and other keywords. The lexer already tries to determine the type of a token, even though that type might change depending on the context. This led to the problematic behavior that no tokens known to the lexer could be used as label names, including operators (and, by, ...), aggregators (count, quantile, ...) or other keywords (for, offset, ...). This change additionally checks whether an identifier is one of these types. We might want to check whether the specific item identification should be moved from the lexer to the parser.
2016-09-07 12:16:34 -07:00
}, {
// Test usage of keywords as label names.
input: "sum without(and, by, avg, count, alert, annotations)(some_metric)",
expected: &AggregateExpr{
Op: itemSum,
Without: true,
Expr: &VectorSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Fix parsing of label names which are also keywords The current separation between lexer and parser is a bit fuzzy when it comes to operators, aggregators and other keywords. The lexer already tries to determine the type of a token, even though that type might change depending on the context. This led to the problematic behavior that no tokens known to the lexer could be used as label names, including operators (and, by, ...), aggregators (count, quantile, ...) or other keywords (for, offset, ...). This change additionally checks whether an identifier is one of these types. We might want to check whether the specific item identification should be moved from the lexer to the parser.
2016-09-07 12:16:34 -07:00
},
},
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
Grouping: []string{"and", "by", "avg", "count", "alert", "annotations"},
Fix parsing of label names which are also keywords The current separation between lexer and parser is a bit fuzzy when it comes to operators, aggregators and other keywords. The lexer already tries to determine the type of a token, even though that type might change depending on the context. This led to the problematic behavior that no tokens known to the lexer could be used as label names, including operators (and, by, ...), aggregators (count, quantile, ...) or other keywords (for, offset, ...). This change additionally checks whether an identifier is one of these types. We might want to check whether the specific item identification should be moved from the lexer to the parser.
2016-09-07 12:16:34 -07:00
},
}, {
input: "sum without(==)(some_metric)",
fail: true,
errMsg: "unexpected <op:==> in grouping opts, expected label",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `sum some_metric by (test)`,
fail: true,
errMsg: "unexpected identifier \"some_metric\" in aggregation, expected \"(\"",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `sum (some_metric) by test`,
fail: true,
errMsg: "unexpected identifier \"test\" in grouping opts, expected \"(\"",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `sum (some_metric) by test`,
fail: true,
errMsg: "unexpected identifier \"test\" in grouping opts, expected \"(\"",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: `sum () by (test)`,
fail: true,
errMsg: "no valid expression found",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Remove keep_common modifier. See #3060
2017-10-05 05:19:52 -07:00
input: "MIN keep_common (some_metric)",
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
fail: true,
Remove keep_common modifier. See #3060
2017-10-05 05:19:52 -07:00
errMsg: "parse error at char 5: unexpected identifier \"keep_common\" in aggregation, expected \"(\"",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Remove keep_common modifier. See #3060
2017-10-05 05:19:52 -07:00
input: "MIN (some_metric) keep_common",
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
fail: true,
Deprecate `keeping_extra`, rename it to `keep_common`. `keep_common` is more in line with the function name `drop_common_labels()` terminology-wise, and also more in line with `group_left`/`group_right` (no `...ing` verb suffix). We could also go the full way and call it `keep_common_labels`. That would have the benefit of being even more consistent with the function `drop_common_labels()` and would be more explanatory, but it also seems quite long.
2015-06-12 05:21:01 -07:00
errMsg: "could not parse remaining input \"keep_common\"...",
Add without aggregator modifier. This has the advantage that the user doesn't need to list all labels they want to keep (as with "by") but without having to worry about inconsistent labels as when there's only one time series (as with "keeping_common"). Almost all aggregation should use this rather than the existing two options as it's much less error prone and easier to maintain due to not having to always add in "job" plus whatever other common job-level labels you have like "region".
2016-02-07 10:03:16 -08:00
}, {
input: `sum (some_metric) without (test) by (test)`,
fail: true,
errMsg: "could not parse remaining input \"by (test)\"...",
}, {
input: `sum without (test) (some_metric) by (test)`,
fail: true,
errMsg: "could not parse remaining input \"by (test)\"...",
Make topk/bottomk aggregators.
2016-07-04 05:10:42 -07:00
}, {
input: `topk(some_metric)`,
fail: true,
errMsg: "parse error at char 17: unexpected \")\" in aggregation, expected \",\"",
Add type check on topk/bottomk parameter.
2016-07-04 10:03:05 -07:00
}, {
input: `topk(some_metric, other_metric)`,
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "parse error at char 32: expected type scalar in aggregation parameter, got instant vector",
Add count_values() aggregator. This is useful for counting how many instances of a job are running a particular version/build. Fixes #622
2016-07-05 09:12:19 -07:00
}, {
input: `count_values(5, other_metric)`,
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "parse error at char 30: expected type string in aggregation parameter, got scalar",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
// Test function calls.
{
input: "time()",
expected: &Call{
Func: mustGetFunction("time"),
},
}, {
input: `floor(some_metric{foo!="bar"})`,
expected: &Call{
Func: mustGetFunction("floor"),
Args: Expressions{
&VectorSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchNotEqual, "foo", "bar"),
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
},
},
}, {
input: "rate(some_metric[5m])",
expected: &Call{
Func: mustGetFunction("rate"),
Args: Expressions{
&MatrixSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
Range: 5 * time.Minute,
},
},
},
}, {
input: "round(some_metric)",
expected: &Call{
Func: mustGetFunction("round"),
Args: Expressions{
&VectorSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
},
},
}, {
input: "round(some_metric, 5)",
expected: &Call{
Func: mustGetFunction("round"),
Args: Expressions{
&VectorSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
&NumberLiteral{5},
},
},
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "floor()",
fail: true,
implement label_join issue 1147 (#2806) Replace OptionalArgs int with Variadic int.
2017-06-16 06:51:22 -07:00
errMsg: "expected 1 argument(s) in call to \"floor\", got 0",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "floor(some_metric, other_metric)",
fail: true,
implement label_join issue 1147 (#2806) Replace OptionalArgs int with Variadic int.
2017-06-16 06:51:22 -07:00
errMsg: "expected 1 argument(s) in call to \"floor\", got 2",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "floor(1)",
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "expected type instant vector in call to function \"floor\", got scalar",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix common english misspellings
2016-09-14 20:23:28 -07:00
input: "non_existent_function_far_bar()",
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
fail: true,
Fix common english misspellings
2016-09-14 20:23:28 -07:00
errMsg: "unknown function with name \"non_existent_function_far_bar\"",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
input: "rate(some_metric)",
fail: true,
promql: misc fixes
2016-12-28 00:16:48 -08:00
errMsg: "expected type range vector in call to function \"rate\", got instant vector",
Check for invalid utf-8 in lexer strings. This protects against invalid utf-8 sneaking in via label_replace.
2017-06-16 07:19:24 -07:00
}, {
input: "label_replace(a, `b`, `c\xff`, `d`, `.*`)",
fail: true,
errMsg: "parse error at char 23: invalid UTF-8 rune",
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
Add missing check for nil expression
2015-08-03 03:28:40 -07:00
// Fuzzing regression tests.
{
input: "-=",
fail: true,
errMsg: `no valid expression found`,
Implement unary expression for vector types. Closes #956
2015-08-04 05:57:34 -07:00
}, {
Add missing check for nil expression
2015-08-03 03:28:40 -07:00
input: "++-++-+-+-<",
fail: true,
errMsg: `no valid expression found`,
Implement unary expression for vector types. Closes #956
2015-08-04 05:57:34 -07:00
}, {
Add missing check for nil expression
2015-08-03 03:28:40 -07:00
input: "e-+=/(0)",
fail: true,
errMsg: `no valid expression found`,
Implement unary expression for vector types. Closes #956
2015-08-04 05:57:34 -07:00
}, {
Add missing check for nil expression
2015-08-03 03:28:40 -07:00
input: "-If",
fail: true,
errMsg: `no valid expression found`,
},
Support escape sequences in strings and add raw strings. This adapts some functionality from the Go standard library for string literal lexing and unquoting/unescaping. The following string types are now supported: Double- or single-quoted strings: These support all escape sequences that Go supports in double-quoted string literals. The difference is that Prometheus also has single-quoted strings (instead of single-quoted runes in Go). Raw newlines are not allowed. Backtick-quoted raw strings: Strings quoted in backticks are treated as raw strings just like in Go and may contain raw newlines and other special characters directly. Fixes https://github.com/prometheus/prometheus/issues/1122 Fixes https://github.com/prometheus/prometheus/issues/1121
2015-09-30 12:27:08 -07:00
// String quoting and escape sequence interpretation tests.
{
input: `"double-quoted string \" with escaped quote"`,
expected: &StringLiteral{
Val: "double-quoted string \" with escaped quote",
},
}, {
input: `'single-quoted string \' with escaped quote'`,
expected: &StringLiteral{
Val: "single-quoted string ' with escaped quote",
},
}, {
input: "`backtick-quoted string`",
expected: &StringLiteral{
Val: "backtick-quoted string",
},
}, {
input: `"\a\b\f\n\r\t\v\\\" - \xFF\377\u1234\U00010111\U0001011111☺"`,
expected: &StringLiteral{
Val: "\a\b\f\n\r\t\v\\\" - \xFF\377\u1234\U00010111\U0001011111☺",
},
}, {
input: `'\a\b\f\n\r\t\v\\\' - \xFF\377\u1234\U00010111\U0001011111☺'`,
expected: &StringLiteral{
Val: "\a\b\f\n\r\t\v\\' - \xFF\377\u1234\U00010111\U0001011111☺",
},
}, {
input: "`" + `\a\b\f\n\r\t\v\\\"\' - \xFF\377\u1234\U00010111\U0001011111☺` + "`",
expected: &StringLiteral{
Val: `\a\b\f\n\r\t\v\\\"\' - \xFF\377\u1234\U00010111\U0001011111☺`,
},
}, {
input: "`\\``",
fail: true,
errMsg: "could not parse remaining input",
}, {
input: `"\`,
fail: true,
errMsg: "escape sequence not terminated",
}, {
input: `"\c"`,
fail: true,
errMsg: "unknown escape sequence U+0063 'c'",
}, {
input: `"\x."`,
fail: true,
errMsg: "illegal character U+002E '.' in escape sequence",
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}
func TestParseExpressions(t *testing.T) {
for _, test := range testExpr {
Parser test cleanup (#3977) * parser test cleanup - Test against the exported package functions instead of the private functions. * Improves readability of TestParseSeries - Moves package function closer to parser function
2018-03-20 07:30:52 -07:00
expr, err := ParseExpr(test.input)
forbid unexpected (runtime) errors in parse tests
2015-08-03 03:53:31 -07:00
// Unexpected errors are always caused by a bug.
if err == errUnexpected {
t.Fatalf("unexpected error occurred")
}
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
if !test.fail && err != nil {
t.Errorf("error in input '%s'", test.input)
t.Fatalf("could not parse: %s", err)
}
Parser test cleanup (#3977) * parser test cleanup - Test against the exported package functions instead of the private functions. * Improves readability of TestParseSeries - Moves package function closer to parser function
2018-03-20 07:30:52 -07:00
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
if test.fail && err != nil {
Fix and improve parsing error output.
2015-04-29 07:35:18 -07:00
if !strings.Contains(err.Error(), test.errMsg) {
t.Errorf("unexpected error on input '%s'", test.input)
t.Fatalf("expected error to contain %q but got %q", test.errMsg, err)
}
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
continue
}
if !reflect.DeepEqual(expr, test.expected) {
t.Errorf("error on input '%s'", test.input)
t.Fatalf("no match\n\nexpected:\n%s\ngot: \n%s\n", Tree(test.expected), Tree(expr))
}
}
}
// NaN has no equality. Thus, we need a separate test for it.
func TestNaNExpression(t *testing.T) {
Parser test cleanup (#3977) * parser test cleanup - Test against the exported package functions instead of the private functions. * Improves readability of TestParseSeries - Moves package function closer to parser function
2018-03-20 07:30:52 -07:00
expr, err := ParseExpr("NaN")
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
if err != nil {
t.Errorf("error on input 'NaN'")
Fix spelling mistakes found by codespell (#4065) Signed-off-by: Karsten Weiss <knweiss@gmail.com>
2018-04-27 05:04:02 -07:00
t.Fatalf("could not parse: %s", err)
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}
nl, ok := expr.(*NumberLiteral)
if !ok {
t.Errorf("error on input 'NaN'")
t.Fatalf("expected number literal but got %T", expr)
}
if !math.IsNaN(float64(nl.Val)) {
t.Errorf("error on input 'NaN'")
Fix unkeyed field errors.
2015-09-18 07:51:53 -07:00
t.Fatalf("expected 'NaN' in number literal but got %v", nl.Val)
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}
}
var testStatement = []struct {
input string
expected Statements
fail bool
}{
{
// Test a file-like input.
input: `
# A simple test recording rule.
dc:http_request:rate5m = sum(rate(http_request_count[5m])) by (dc)
Consolidate offset modifier parsing Remove duplicated offset modifier parsing and ensure offset can only appear at the end of a selector statement.
2016-01-24 19:50:46 -08:00
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
# A simple test alerting rule.
Change WITH keyword to LABELS
2015-12-23 05:54:02 -08:00
ALERT GlobalRequestRateLow IF(dc:http_request:rate5m < 10000) FOR 5m
LABELS {
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
service = "testservice"
# ... more fields here ...
}
Implement new alerting rule syntax
2015-12-11 08:02:34 -08:00
ANNOTATIONS {
summary = "Global request rate low",
description = "The global request rate is low"
}
promql: misc fixes
2016-12-28 00:16:48 -08:00
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
foo = bar{label1="value1"}
promql: add runbook to alert statement. This commit adds the RUNBOOK keyword to alert statements. The field is optional and expected to be a link.
2015-06-24 10:27:09 -07:00
ALERT BazAlert IF foo > 10
Implement new alerting rule syntax
2015-12-11 08:02:34 -08:00
ANNOTATIONS {
description = "BazAlert",
runbook = "http://my.url",
summary = "Baz",
}
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
`,
expected: Statements{
&RecordStmt{
Name: "dc:http_request:rate5m",
Expr: &AggregateExpr{
Op: itemSum,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
Grouping: []string{"dc"},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
Expr: &Call{
Func: mustGetFunction("rate"),
Args: Expressions{
&MatrixSelector{
Name: "http_request_count",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "http_request_count"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
Range: 5 * time.Minute,
},
},
},
},
Labels: nil,
},
&AlertStmt{
Name: "GlobalRequestRateLow",
Expr: &ParenExpr{&BinaryExpr{
Op: itemLSS,
LHS: &VectorSelector{
Name: "dc:http_request:rate5m",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "dc:http_request:rate5m"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
RHS: &NumberLiteral{10000},
}},
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
Labels: labels.FromStrings("service", "testservice"),
Implement new alerting rule syntax
2015-12-11 08:02:34 -08:00
Duration: 5 * time.Minute,
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
Annotations: labels.FromStrings(
"summary", "Global request rate low",
"description", "The global request rate is low",
),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
&RecordStmt{
Name: "foo",
Expr: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, "label1", "value1"),
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
},
&AlertStmt{
Name: "BazAlert",
Expr: &BinaryExpr{
Op: itemGTR,
LHS: &VectorSelector{
Name: "foo",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "foo"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
RHS: &NumberLiteral{10},
},
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
Annotations: labels.FromStrings(
"summary", "Baz",
"description", "BazAlert",
"runbook", "http://my.url",
),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
}, {
input: `foo{x="", a="z"} = bar{a="b", x=~"y"}`,
expected: Statements{
&RecordStmt{
Name: "foo",
Expr: &VectorSelector{
Name: "bar",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, "a", "b"),
mustLabelMatcher(labels.MatchRegexp, "x", "y"),
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "bar"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
Labels: labels.FromStrings("x", "", "a", "z"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
Support old alerting rule syntax
2016-01-11 02:39:22 -08:00
}, {
input: `ALERT SomeName IF some_metric > 1
LABELS {}
Implement new alerting rule syntax
2015-12-11 08:02:34 -08:00
ANNOTATIONS {
Support old alerting rule syntax
2016-01-11 02:39:22 -08:00
summary = "Global request rate low",
description = "The global request rate is low",
Implement new alerting rule syntax
2015-12-11 08:02:34 -08:00
}
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
`,
expected: Statements{
&AlertStmt{
Name: "SomeName",
Expr: &BinaryExpr{
Op: itemGTR,
LHS: &VectorSelector{
Name: "some_metric",
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
LabelMatchers: []*labels.Matcher{
mustLabelMatcher(labels.MatchEqual, string(model.MetricNameLabel), "some_metric"),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
RHS: &NumberLiteral{1},
},
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
Labels: labels.Labels{},
Annotations: labels.FromStrings(
"summary", "Global request rate low",
"description", "The global request rate is low",
),
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
},
},
}, {
input: `
# A simple test alerting rule.
Change WITH keyword to LABELS
2015-12-23 05:54:02 -08:00
ALERT GlobalRequestRateLow IF(dc:http_request:rate5m < 10000) FOR 5
LABELS {
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
service = "testservice"
Consolidate offset modifier parsing Remove duplicated offset modifier parsing and ensure offset can only appear at the end of a selector statement.
2016-01-24 19:50:46 -08:00
# ... more fields here ...
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}
Implement new alerting rule syntax
2015-12-11 08:02:34 -08:00
ANNOTATIONS {
summary = "Global request rate low"
description = "The global request rate is low"
}
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
`,
fail: true,
}, {
input: "",
expected: Statements{},
}, {
input: "foo = time()",
rules: Allow recorded rules expressions to be scalars. This is useful if you want to build up a constant metric, such as a set of alert thresholds that vary by label value.
2015-08-19 13:09:00 -07:00
expected: Statements{
&RecordStmt{
Name: "foo",
Expr: &Call{Func: mustGetFunction("time")},
Labels: nil,
}},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
input: "foo = 1",
rules: Allow recorded rules expressions to be scalars. This is useful if you want to build up a constant metric, such as a set of alert thresholds that vary by label value.
2015-08-19 13:09:00 -07:00
expected: Statements{
&RecordStmt{
Name: "foo",
Expr: &NumberLiteral{1},
Labels: nil,
}},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}, {
input: "foo = bar[5m]",
fail: true,
}, {
input: `foo = "test"`,
fail: true,
}, {
input: `foo = `,
fail: true,
}, {
input: `foo{a!="b"} = bar`,
fail: true,
}, {
input: `foo{a=~"b"} = bar`,
fail: true,
}, {
input: `foo{a!~"b"} = bar`,
fail: true,
},
forbid unexpected (runtime) errors in parse tests
2015-08-03 03:53:31 -07:00
// Fuzzing regression tests.
{
input: `I=-/`,
fail: true,
},
{
input: `I=3E8/-=`,
fail: true,
},
{
input: `M=-=-0-0`,
fail: true,
},
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
}
func TestParseStatements(t *testing.T) {
for _, test := range testStatement {
Parser test cleanup (#3977) * parser test cleanup - Test against the exported package functions instead of the private functions. * Improves readability of TestParseSeries - Moves package function closer to parser function
2018-03-20 07:30:52 -07:00
stmts, err := ParseStmts(test.input)
forbid unexpected (runtime) errors in parse tests
2015-08-03 03:53:31 -07:00
// Unexpected errors are always caused by a bug.
if err == errUnexpected {
t.Fatalf("unexpected error occurred")
}
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
if !test.fail && err != nil {
t.Errorf("error in input: \n\n%s\n", test.input)
t.Fatalf("could not parse: %s", err)
}
if test.fail && err != nil {
continue
}
if !reflect.DeepEqual(stmts, test.expected) {
t.Errorf("error in input: \n\n%s\n", test.input)
t.Fatalf("no match\n\nexpected:\n%s\ngot: \n%s\n", Tree(test.expected), Tree(stmts))
}
}
}
*: fix misc compile errors
2016-12-25 02:34:22 -08:00
func mustLabelMatcher(mt labels.MatchType, name, val string) *labels.Matcher {
m, err := labels.NewMatcher(mt, name, val)
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
if err != nil {
panic(err)
}
return m
}
func mustGetFunction(name string) *Function {
Refactor query evaluation. This copies the evaluation logic from the current rules/ package. The new engine handles the execution process from query string to final result. It provides query timeout and cancellation and general flexibility for future changes. functions.go: Add evaluation implementation. Slight changes to in/out data but not to the processing logic. quantile.go: No changes. analyzer.go: No changes. engine.go: Actually new part. Mainly consists of evaluation methods which were not changed. setup_test.go: Copy of rules/helpers_test.go to setup test storage. promql_test.go: Copy of rules/rules_test.go.
2015-03-30 10:13:36 -07:00
f, ok := getFunction(name)
Create promql package with lexer/parser. This commit creates a (so far unused) package. It contains the a custom lexer/parser for the query language. ast.go: New AST that interacts well with the parser. lex.go: Custom lexer (new). lex_test.go: Lexer tests (new). parse.go: Custom parser (new). parse_test.go: Parser tests (new). functions.go: Changed function type, dummies for parser testing (barely changed/dummies). printer.go: Adapted from rules/ and adjusted to new AST (mostly unchanged, few additions).
2015-03-30 09:12:51 -07:00
if !ok {
panic(fmt.Errorf("function %q does not exist", name))
}
return f
}
Add time series description parsing. This commit adds parsing of time series description to the exisiting query language parser. Time series descriptions are defined by a metric followed by a sequence of values.
2015-05-11 05:04:53 -07:00
var testSeries = []struct {
input string
promql: misc fixes
2016-12-28 00:16:48 -08:00
expectedMetric labels.Labels
Add time series description parsing. This commit adds parsing of time series description to the exisiting query language parser. Time series descriptions are defined by a metric followed by a sequence of values.
2015-05-11 05:04:53 -07:00
expectedValues []sequenceValue
fail bool
}{
{
input: `{} 1 2 3`,
promql: misc fixes
2016-12-28 00:16:48 -08:00
expectedMetric: labels.Labels{},
Add time series description parsing. This commit adds parsing of time series description to the exisiting query language parser. Time series descriptions are defined by a metric followed by a sequence of values.
2015-05-11 05:04:53 -07:00
expectedValues: newSeq(1, 2, 3),
}, {
promql: misc fixes
2016-12-28 00:16:48 -08:00
input: `{a="b"} -1 2 3`,
expectedMetric: labels.FromStrings("a", "b"),
Add time series description parsing. This commit adds parsing of time series description to the exisiting query language parser. Time series descriptions are defined by a metric followed by a sequence of values.
2015-05-11 05:04:53 -07:00
expectedValues: newSeq(-1, 2, 3),
}, {
promql: misc fixes
2016-12-28 00:16:48 -08:00
input: `my_metric 1 2 3`,
expectedMetric: labels.FromStrings(labels.MetricName, "my_metric"),
Add time series description parsing. This commit adds parsing of time series description to the exisiting query language parser. Time series descriptions are defined by a metric followed by a sequence of values.
2015-05-11 05:04:53 -07:00
expectedValues: newSeq(1, 2, 3),
}, {
promql: misc fixes
2016-12-28 00:16:48 -08:00
input: `my_metric{} 1 2 3`,
expectedMetric: labels.FromStrings(labels.MetricName, "my_metric"),
Add time series description parsing. This commit adds parsing of time series description to the exisiting query language parser. Time series descriptions are defined by a metric followed by a sequence of values.
2015-05-11 05:04:53 -07:00
expectedValues: newSeq(1, 2, 3),
}, {
promql: misc fixes
2016-12-28 00:16:48 -08:00
input: `my_metric{a="b"} 1 2 3`,
expectedMetric: labels.FromStrings(labels.MetricName, "my_metric", "a", "b"),
Add time series description parsing. This commit adds parsing of time series description to the exisiting query language parser. Time series descriptions are defined by a metric followed by a sequence of values.
2015-05-11 05:04:53 -07:00
expectedValues: newSeq(1, 2, 3),
}, {
promql: misc fixes
2016-12-28 00:16:48 -08:00
input: `my_metric{a="b"} 1 2 3-10x4`,
expectedMetric: labels.FromStrings(labels.MetricName, "my_metric", "a", "b"),
Add time series description parsing. This commit adds parsing of time series description to the exisiting query language parser. Time series descriptions are defined by a metric followed by a sequence of values.
2015-05-11 05:04:53 -07:00
expectedValues: newSeq(1, 2, 3, -7, -17, -27, -37),
promql: fix parsing ambiguity for serial repetitions
2015-06-04 09:21:24 -07:00
}, {
promql: misc fixes
2016-12-28 00:16:48 -08:00
input: `my_metric{a="b"} 1 2 3-0x4`,
expectedMetric: labels.FromStrings(labels.MetricName, "my_metric", "a", "b"),
promql: fix parsing ambiguity for serial repetitions
2015-06-04 09:21:24 -07:00
expectedValues: newSeq(1, 2, 3, 3, 3, 3, 3),
Add time series description parsing. This commit adds parsing of time series description to the exisiting query language parser. Time series descriptions are defined by a metric followed by a sequence of values.
2015-05-11 05:04:53 -07:00
}, {
promql: misc fixes
2016-12-28 00:16:48 -08:00
input: `my_metric{a="b"} 1 3 _ 5 _x4`,
expectedMetric: labels.FromStrings(labels.MetricName, "my_metric", "a", "b"),
Add time series description parsing. This commit adds parsing of time series description to the exisiting query language parser. Time series descriptions are defined by a metric followed by a sequence of values.
2015-05-11 05:04:53 -07:00
expectedValues: newSeq(1, 3, none, 5, none, none, none, none),
}, {
input: `my_metric{a="b"} 1 3 _ 5 _a4`,
fail: true,
},
}
Add parsing and execution of new test format. This commit adds a new test structure that parses and executes the new testing language.
2015-05-11 06:56:35 -07:00
// For these tests only, we use the smallest float64 to signal an omitted value.
Add time series description parsing. This commit adds parsing of time series description to the exisiting query language parser. Time series descriptions are defined by a metric followed by a sequence of values.
2015-05-11 05:04:53 -07:00
const none = math.SmallestNonzeroFloat64
func newSeq(vals ...float64) (res []sequenceValue) {
for _, v := range vals {
if v == none {
res = append(res, sequenceValue{omitted: true})
} else {
promql: migrate model types, use tsdb interfaces
2016-12-23 04:51:59 -08:00
res = append(res, sequenceValue{value: v})
Add time series description parsing. This commit adds parsing of time series description to the exisiting query language parser. Time series descriptions are defined by a metric followed by a sequence of values.
2015-05-11 05:04:53 -07:00
}
}
return res
}
func TestParseSeries(t *testing.T) {
for _, test := range testSeries {
Parser test cleanup (#3977) * parser test cleanup - Test against the exported package functions instead of the private functions. * Improves readability of TestParseSeries - Moves package function closer to parser function
2018-03-20 07:30:52 -07:00
metric, vals, err := parseSeriesDesc(test.input)
forbid unexpected (runtime) errors in parse tests
2015-08-03 03:53:31 -07:00
// Unexpected errors are always caused by a bug.
if err == errUnexpected {
t.Fatalf("unexpected error occurred")
}
Add time series description parsing. This commit adds parsing of time series description to the exisiting query language parser. Time series descriptions are defined by a metric followed by a sequence of values.
2015-05-11 05:04:53 -07:00
if test.fail {
if err != nil {
continue
}
t.Errorf("error in input: \n\n%s\n", test.input)
t.Fatalf("failure expected, but passed")
Parser test cleanup (#3977) * parser test cleanup - Test against the exported package functions instead of the private functions. * Improves readability of TestParseSeries - Moves package function closer to parser function
2018-03-20 07:30:52 -07:00
} else {
if err != nil {
t.Errorf("error in input: \n\n%s\n", test.input)
t.Fatalf("could not parse: %s", err)
}
Add time series description parsing. This commit adds parsing of time series description to the exisiting query language parser. Time series descriptions are defined by a metric followed by a sequence of values.
2015-05-11 05:04:53 -07:00
}
promql: misc fixes
2016-12-28 00:16:48 -08:00
require.Equal(t, test.expectedMetric, metric)
require.Equal(t, test.expectedValues, vals)
Add time series description parsing. This commit adds parsing of time series description to the exisiting query language parser. Time series descriptions are defined by a metric followed by a sequence of values.
2015-05-11 05:04:53 -07:00
if !reflect.DeepEqual(vals, test.expectedValues) || !reflect.DeepEqual(metric, test.expectedMetric) {
t.Errorf("error in input: \n\n%s\n", test.input)
t.Fatalf("no match\n\nexpected:\n%s %s\ngot: \n%s %s\n", test.expectedMetric, test.expectedValues, metric, vals)
}
}
}
Handle parser runtime panics gracefully
2015-08-02 04:37:42 -07:00
Log runtime errors during query evaluation instead of panicking.
2015-08-19 06:28:53 -07:00
func TestRecoverParserRuntime(t *testing.T) {
Handle parser runtime panics gracefully
2015-08-02 04:37:42 -07:00
var p *parser
var err error
defer p.recover(&err)
// Cause a runtime panic.
var a []int
a[123] = 1
forbid unexpected (runtime) errors in parse tests
2015-08-03 03:53:31 -07:00
if err != errUnexpected {
t.Fatalf("wrong error message: %q, expected %q", err, errUnexpected)
Handle parser runtime panics gracefully
2015-08-02 04:37:42 -07:00
}
}
Log runtime errors during query evaluation instead of panicking.
2015-08-19 06:28:53 -07:00
func TestRecoverParserError(t *testing.T) {
Handle parser runtime panics gracefully
2015-08-02 04:37:42 -07:00
var p *parser
var err error
e := fmt.Errorf("custom error")
Fix "go vet" errors. I ignored all errors of the type "composite literal uses unkeyed fields". Most of them are wrong because of https://github.com/golang/go/issues/9171.
2015-08-25 17:04:01 -07:00
defer func() {
if err.Error() != e.Error() {
t.Fatalf("wrong error message: %q, expected %q", err, e)
}
}()
defer p.recover(&err)
panic(e)
Handle parser runtime panics gracefully
2015-08-02 04:37:42 -07:00
}
Reference in a new issue Copy permalink