prometheus/rules/lexer.l.go

2739 lines
53 KiB
Go
Raw Normal View History

/* Copyright 2013 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 rules
import (
"fmt"
"strconv"
"strings"
clientmodel "github.com/prometheus/client_golang/model"
)
// Lex is called by the parser generated by "go tool yacc" to obtain each
// token. The method is opened before the matching rules block and closed at
// the end of the file.
func (lexer *RulesLexer) Lex(lval *yySymType) int {
// Internal lexer states.
const (
S_INITIAL = iota
S_COMMENTS
)
// We simulate multiple start symbols for closely-related grammars via dummy tokens. See
// http://www.gnu.org/software/bison/manual/html_node/Multiple-start_002dsymbols.html
// Reason: we want to be able to parse lists of named rules as well as single expressions.
if lexer.startToken != 0 {
startToken := lexer.startToken
lexer.startToken = 0
return startToken
}
c := lexer.current
currentState := 0
if lexer.empty {
c, lexer.empty = lexer.getChar(), false
}
yystate0:
lexer.buf = lexer.buf[:0] // The code before the first rule executed before every scan cycle (rule #0 / state 0 action)
switch yyt := currentState; yyt {
default:
panic(fmt.Errorf(`invalid start condition %d`, yyt))
case 0: // start condition: INITIAL
goto yystart1
case 1: // start condition: S_COMMENTS
goto yystart197
}
goto yystate0 // silence unused label error
goto yystate1 // silence unused label error
yystate1:
c = lexer.getChar()
yystart1:
switch {
default:
goto yyabort
case c == '!':
goto yystate3
case c == '"':
goto yystate5
case c == '%' || c == '*':
goto yystate8
case c == '(' || c == ')' || c == ',' || c == '[' || c == ']' || c == '{' || c == '}':
goto yystate11
case c == '+' || c == '-':
goto yystate12
case c == '.':
goto yystate16
case c == '/':
goto yystate21
case c == ':':
goto yystate27
case c == '<' || c == '>':
goto yystate28
case c == '=':
goto yystate29
case c == 'A':
goto yystate30
case c == 'B':
goto yystate40
case c == 'C':
goto yystate42
case c == 'D':
goto yystate46
case c == 'E' || c == 'H' || c == 'J' || c == 'L' || c == 'Q' || c == 'R' || c >= 'T' && c <= 'V' || c >= 'X' && c <= 'Z' || c == '_' || c == 'e' || c == 'h' || c == 'j' || c == 'l' || c == 'q' || c == 'r' || c >= 't' && c <= 'v' || c >= 'x' && c <= 'z':
goto yystate31
case c == 'F':
goto yystate57
case c == 'G':
goto yystate60
case c == 'I':
goto yystate73
case c == 'K':
goto yystate77
case c == 'M':
goto yystate90
case c == 'N' || c == 'n':
goto yystate93
case c == 'O':
goto yystate95
case c == 'P':
goto yystate102
case c == 'S':
goto yystate111
case c == 'W':
goto yystate118
case c == '\'':
goto yystate9
case c == '\t' || c == '\n' || c == '\r' || c == ' ':
goto yystate2
case c == 'a':
goto yystate122
case c == 'b':
goto yystate129
case c == 'c':
goto yystate130
case c == 'd':
goto yystate134
case c == 'f':
goto yystate144
case c == 'g':
goto yystate146
case c == 'i':
goto yystate159
case c == 'k':
goto yystate160
case c == 'm':
goto yystate172
case c == 'o':
goto yystate175
case c == 'p':
goto yystate180
case c == 's':
goto yystate188
case c == 'w':
goto yystate194
case c >= '0' && c <= '9':
goto yystate25
}
yystate2:
c = lexer.getChar()
goto yyrule30
yystate3:
c = lexer.getChar()
switch {
default:
goto yyabort
case c == '=' || c == '~':
goto yystate4
}
yystate4:
c = lexer.getChar()
goto yyrule21
yystate5:
c = lexer.getChar()
switch {
default:
goto yyabort
case c == '"':
goto yystate6
case c == '\\':
goto yystate7
case c >= '\x01' && c <= '!' || c >= '#' && c <= '[' || c >= ']' && c <= 'ÿ':
goto yystate5
}
yystate6:
c = lexer.getChar()
goto yyrule28
yystate7:
c = lexer.getChar()
switch {
default:
goto yyabort
case c >= '\x01' && c <= '\t' || c >= '\v' && c <= 'ÿ':
goto yystate5
}
yystate8:
c = lexer.getChar()
goto yyrule23
yystate9:
c = lexer.getChar()
switch {
default:
goto yyabort
case c == '\'':
goto yystate6
case c == '\\':
goto yystate10
case c >= '\x01' && c <= '&' || c >= '(' && c <= '[' || c >= ']' && c <= 'ÿ':
goto yystate9
}
yystate10:
c = lexer.getChar()
switch {
default:
goto yyabort
case c >= '\x01' && c <= '\t' || c >= '\v' && c <= 'ÿ':
goto yystate9
}
yystate11:
c = lexer.getChar()
goto yyrule29
yystate12:
c = lexer.getChar()
switch {
default:
goto yyrule22
case c == 'I' || c == 'i':
goto yystate13
}
yystate13:
c = lexer.getChar()
switch {
default:
goto yyabort
case c == 'N' || c == 'n':
goto yystate14
}
yystate14:
c = lexer.getChar()
switch {
default:
goto yyabort
case c == 'F' || c == 'f':
goto yystate15
}
yystate15:
c = lexer.getChar()
goto yyrule24
yystate16:
c = lexer.getChar()
switch {
default:
goto yyabort
case c >= '0' && c <= '9':
goto yystate17
}
yystate17:
c = lexer.getChar()
switch {
default:
goto yyrule24
case c == 'E' || c == 'e':
goto yystate18
case c >= '0' && c <= '9':
goto yystate17
}
yystate18:
c = lexer.getChar()
switch {
default:
goto yyabort
case c == '+' || c == '-':
goto yystate19
case c >= '0' && c <= '9':
goto yystate20
}
yystate19:
c = lexer.getChar()
switch {
default:
goto yyabort
case c >= '0' && c <= '9':
goto yystate20
}
yystate20:
c = lexer.getChar()
switch {
default:
goto yyrule24
case c >= '0' && c <= '9':
goto yystate20
}
yystate21:
c = lexer.getChar()
switch {
default:
goto yyrule23
case c == '*':
goto yystate22
case c == '/':
goto yystate23
}
yystate22:
c = lexer.getChar()
goto yyrule1
yystate23:
c = lexer.getChar()
switch {
default:
goto yyabort
case c == '\n':
goto yystate24
case c >= '\x01' && c <= '\t' || c == '\v' || c == '\f' || c >= '\x0e' && c <= 'ÿ':
goto yystate23
}
yystate24:
c = lexer.getChar()
goto yyrule4
yystate25:
c = lexer.getChar()
switch {
default:
goto yyrule24
case c == '.':
goto yystate17
case c == 'E' || c == 'e':
goto yystate18
case c == 'd' || c == 'h' || c == 'm' || c == 's' || c == 'w' || c == 'y':
goto yystate26
case c >= '0' && c <= '9':
goto yystate25
}
yystate26:
c = lexer.getChar()
goto yyrule25
yystate27:
c = lexer.getChar()
switch {
default:
goto yyrule27
case c >= '0' && c <= ':' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate27
}
yystate28:
c = lexer.getChar()
switch {
default:
goto yyrule20
case c == '=':
goto yystate4
}
yystate29:
c = lexer.getChar()
switch {
default:
goto yyrule29
case c == '=' || c == '~':
goto yystate4
}
yystate30:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'L':
goto yystate32
case c == 'N':
goto yystate36
case c == 'V':
goto yystate38
case c >= '0' && c <= '9' || c >= 'A' && c <= 'K' || c == 'M' || c >= 'O' && c <= 'U' || c >= 'W' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate31:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate32:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'E':
goto yystate33
case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate33:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'R':
goto yystate34
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate34:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'T':
goto yystate35
case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate35:
c = lexer.getChar()
switch {
default:
goto yyrule5
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate36:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'D':
goto yystate37
case c >= '0' && c <= '9' || c >= 'A' && c <= 'C' || c >= 'E' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate37:
c = lexer.getChar()
switch {
default:
goto yyrule20
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate38:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'G':
goto yystate39
case c >= '0' && c <= '9' || c >= 'A' && c <= 'F' || c >= 'H' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate39:
c = lexer.getChar()
switch {
default:
goto yyrule18
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate40:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'Y':
goto yystate41
case c >= '0' && c <= '9' || c >= 'A' && c <= 'X' || c == 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate41:
c = lexer.getChar()
switch {
default:
goto yyrule12
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate42:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'O':
goto yystate43
case c >= '0' && c <= '9' || c >= 'A' && c <= 'N' || c >= 'P' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate43:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'U':
goto yystate44
case c >= '0' && c <= '9' || c >= 'A' && c <= 'T' || c >= 'V' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate44:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'N':
goto yystate45
case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate45:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'T':
goto yystate39
case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate46:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'E':
goto yystate47
case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate47:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'S':
goto yystate48
case c >= '0' && c <= '9' || c >= 'A' && c <= 'R' || c >= 'T' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate48:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'C':
goto yystate49
case c >= '0' && c <= '9' || c == 'A' || c == 'B' || c >= 'D' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate49:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'R':
goto yystate50
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate50:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'I':
goto yystate51
case c >= '0' && c <= '9' || c >= 'A' && c <= 'H' || c >= 'J' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate51:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'P':
goto yystate52
case c >= '0' && c <= '9' || c >= 'A' && c <= 'O' || c >= 'Q' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate52:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'T':
goto yystate53
case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate53:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'I':
goto yystate54
case c >= '0' && c <= '9' || c >= 'A' && c <= 'H' || c >= 'J' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate54:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'O':
goto yystate55
case c >= '0' && c <= '9' || c >= 'A' && c <= 'N' || c >= 'P' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate55:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'N':
goto yystate56
case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate56:
c = lexer.getChar()
switch {
default:
goto yyrule10
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate57:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'O':
goto yystate58
case c >= '0' && c <= '9' || c >= 'A' && c <= 'N' || c >= 'P' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate58:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'R':
goto yystate59
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate59:
c = lexer.getChar()
switch {
default:
goto yyrule7
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate60:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'R':
goto yystate61
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate61:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'O':
goto yystate62
case c >= '0' && c <= '9' || c >= 'A' && c <= 'N' || c >= 'P' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate62:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'U':
goto yystate63
case c >= '0' && c <= '9' || c >= 'A' && c <= 'T' || c >= 'V' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate63:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'P':
goto yystate64
case c >= '0' && c <= '9' || c >= 'A' && c <= 'O' || c >= 'Q' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate64:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == '_':
goto yystate65
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate65:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'L':
goto yystate66
case c == 'R':
goto yystate70
case c >= '0' && c <= '9' || c >= 'A' && c <= 'K' || c >= 'M' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate66:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'E':
goto yystate67
case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate67:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'F':
goto yystate68
case c >= '0' && c <= '9' || c >= 'A' && c <= 'E' || c >= 'G' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate68:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'T':
goto yystate69
case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate69:
c = lexer.getChar()
switch {
default:
goto yyrule14
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate70:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'I':
goto yystate71
case c >= '0' && c <= '9' || c >= 'A' && c <= 'H' || c >= 'J' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate71:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'G':
goto yystate72
case c >= '0' && c <= '9' || c >= 'A' && c <= 'F' || c >= 'H' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate72:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'H':
goto yystate68
case c >= '0' && c <= '9' || c >= 'A' && c <= 'G' || c >= 'I' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate73:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'F':
goto yystate74
case c == 'N' || c == 'n':
goto yystate75
case c >= '0' && c <= '9' || c >= 'A' && c <= 'E' || c >= 'G' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z':
goto yystate31
}
yystate74:
c = lexer.getChar()
switch {
default:
goto yyrule6
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate75:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'F' || c == 'f':
goto yystate76
case c >= '0' && c <= '9' || c >= 'A' && c <= 'E' || c >= 'G' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'e' || c >= 'g' && c <= 'z':
goto yystate31
}
yystate76:
c = lexer.getChar()
switch {
default:
goto yyrule24
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate77:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'E':
goto yystate78
case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate78:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'E':
goto yystate79
case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate79:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'P':
goto yystate80
case c >= '0' && c <= '9' || c >= 'A' && c <= 'O' || c >= 'Q' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate80:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'I':
goto yystate81
case c >= '0' && c <= '9' || c >= 'A' && c <= 'H' || c >= 'J' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate81:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'N':
goto yystate82
case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate82:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'G':
goto yystate83
case c >= '0' && c <= '9' || c >= 'A' && c <= 'F' || c >= 'H' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate83:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == '_':
goto yystate84
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate84:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'E':
goto yystate85
case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate85:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'X':
goto yystate86
case c >= '0' && c <= '9' || c >= 'A' && c <= 'W' || c == 'Y' || c == 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate86:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c == 'T':
goto yystate87
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate87:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'R':
goto yystate88
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate88:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'A':
goto yystate89
case c >= '0' && c <= '9' || c >= 'B' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate89:
c = lexer.getChar()
switch {
default:
goto yyrule16
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate90:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'A':
goto yystate91
case c == 'I':
goto yystate92
case c >= '0' && c <= '9' || c >= 'B' && c <= 'H' || c >= 'J' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate91:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'X':
goto yystate39
case c >= '0' && c <= '9' || c >= 'A' && c <= 'W' || c == 'Y' || c == 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate92:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c == 'N':
goto yystate39
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate93:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'A' || c == 'a':
goto yystate94
case c >= '0' && c <= '9' || c >= 'B' && c <= 'Z' || c == '_' || c >= 'b' && c <= 'z':
goto yystate31
}
yystate94:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'N' || c == 'n':
goto yystate76
case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z':
goto yystate31
}
yystate95:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'F':
goto yystate96
case c == 'N':
goto yystate101
case c == 'R':
goto yystate37
case c >= '0' && c <= '9' || c >= 'A' && c <= 'E' || c >= 'G' && c <= 'M' || c >= 'O' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate96:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'F':
goto yystate97
case c >= '0' && c <= '9' || c >= 'A' && c <= 'E' || c >= 'G' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate97:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'S':
goto yystate98
case c >= '0' && c <= '9' || c >= 'A' && c <= 'R' || c >= 'T' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate98:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'E':
goto yystate99
case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate99:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'T':
goto yystate100
case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate100:
c = lexer.getChar()
switch {
default:
goto yyrule17
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate101:
c = lexer.getChar()
switch {
default:
goto yyrule13
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate102:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'E':
goto yystate103
case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate103:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'R':
goto yystate104
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate104:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'M':
goto yystate105
case c >= '0' && c <= '9' || c >= 'A' && c <= 'L' || c >= 'N' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate105:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'A':
goto yystate106
case c >= '0' && c <= '9' || c >= 'B' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate106:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'N':
goto yystate107
case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate107:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'E':
goto yystate108
case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate108:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'N':
goto yystate109
case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate109:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'T':
goto yystate110
case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate110:
c = lexer.getChar()
switch {
default:
goto yyrule11
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate111:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'U':
goto yystate112
case c >= '0' && c <= '9' || c >= 'A' && c <= 'T' || c >= 'V' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate112:
c = lexer.getChar()
switch {
default:
goto yyrule26
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c == ':':
goto yystate27
case c == 'M':
goto yystate113
case c >= '0' && c <= '9' || c >= 'A' && c <= 'L' || c >= 'N' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
}
yystate113:
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
c = lexer.getChar()
switch {
default:
goto yyrule18
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c == ':':
goto yystate27
case c == 'M':
goto yystate114
case c >= '0' && c <= '9' || c >= 'A' && c <= 'L' || c >= 'N' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
}
yystate114:
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
c = lexer.getChar()
switch {
default:
goto yyrule26
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c == ':':
goto yystate27
case c == 'A':
goto yystate115
case c >= '0' && c <= '9' || c >= 'B' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
}
yystate115:
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
c = lexer.getChar()
switch {
default:
goto yyrule26
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c == ':':
goto yystate27
case c == 'R':
goto yystate116
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
}
yystate116:
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
c = lexer.getChar()
switch {
default:
goto yyrule26
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c == ':':
goto yystate27
case c == 'Y':
goto yystate117
case c >= '0' && c <= '9' || c >= 'A' && c <= 'X' || c == 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
}
yystate117:
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
c = lexer.getChar()
switch {
default:
goto yyrule9
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate118:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'I':
goto yystate119
case c >= '0' && c <= '9' || c >= 'A' && c <= 'H' || c >= 'J' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate119:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'T':
goto yystate120
case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate120:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'H':
goto yystate121
case c >= '0' && c <= '9' || c >= 'A' && c <= 'G' || c >= 'I' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate121:
c = lexer.getChar()
switch {
default:
goto yyrule8
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate122:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'l':
goto yystate123
case c == 'n':
goto yystate126
case c == 'v':
goto yystate127
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'k' || c == 'm' || c >= 'o' && c <= 'u' || c >= 'w' && c <= 'z':
goto yystate31
}
yystate123:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'e':
goto yystate124
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z':
goto yystate31
}
yystate124:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'r':
goto yystate125
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z':
goto yystate31
}
yystate125:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 't':
goto yystate35
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z':
goto yystate31
}
yystate126:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'd':
goto yystate37
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'c' || c >= 'e' && c <= 'z':
goto yystate31
}
yystate127:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'g':
goto yystate128
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'f' || c >= 'h' && c <= 'z':
goto yystate31
}
yystate128:
c = lexer.getChar()
switch {
default:
goto yyrule19
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate129:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'y':
goto yystate41
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'x' || c == 'z':
goto yystate31
}
yystate130:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'o':
goto yystate131
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'n' || c >= 'p' && c <= 'z':
goto yystate31
}
yystate131:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'u':
goto yystate132
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 't' || c >= 'v' && c <= 'z':
goto yystate31
}
yystate132:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'n':
goto yystate133
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z':
goto yystate31
}
yystate133:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 't':
goto yystate128
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z':
goto yystate31
}
yystate134:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'e':
goto yystate135
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z':
goto yystate31
}
yystate135:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 's':
goto yystate136
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'r' || c >= 't' && c <= 'z':
goto yystate31
}
yystate136:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'c':
goto yystate137
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c == 'a' || c == 'b' || c >= 'd' && c <= 'z':
goto yystate31
}
yystate137:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'r':
goto yystate138
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z':
goto yystate31
}
yystate138:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'i':
goto yystate139
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'h' || c >= 'j' && c <= 'z':
goto yystate31
}
yystate139:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'p':
goto yystate140
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'o' || c >= 'q' && c <= 'z':
goto yystate31
}
yystate140:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 't':
goto yystate141
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z':
goto yystate31
}
yystate141:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'i':
goto yystate142
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'h' || c >= 'j' && c <= 'z':
goto yystate31
}
yystate142:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'o':
goto yystate143
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'n' || c >= 'p' && c <= 'z':
goto yystate31
}
yystate143:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'n':
goto yystate56
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z':
goto yystate31
}
yystate144:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'o':
goto yystate145
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'n' || c >= 'p' && c <= 'z':
goto yystate31
}
yystate145:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'r':
goto yystate59
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z':
goto yystate31
}
yystate146:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'r':
goto yystate147
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z':
goto yystate31
}
yystate147:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'o':
goto yystate148
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'n' || c >= 'p' && c <= 'z':
goto yystate31
}
yystate148:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'u':
goto yystate149
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 't' || c >= 'v' && c <= 'z':
goto yystate31
}
yystate149:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'p':
goto yystate150
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'o' || c >= 'q' && c <= 'z':
goto yystate31
}
yystate150:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == '_':
goto yystate151
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate151:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'l':
goto yystate152
case c == 'r':
goto yystate156
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'k' || c >= 'm' && c <= 'q' || c >= 's' && c <= 'z':
goto yystate31
}
yystate152:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'e':
goto yystate153
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z':
goto yystate31
}
yystate153:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'f':
goto yystate154
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'e' || c >= 'g' && c <= 'z':
goto yystate31
}
yystate154:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 't':
goto yystate155
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z':
goto yystate31
}
yystate155:
c = lexer.getChar()
switch {
default:
goto yyrule15
case c == ':':
goto yystate27
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate156:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'i':
goto yystate157
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'h' || c >= 'j' && c <= 'z':
goto yystate31
}
yystate157:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'g':
goto yystate158
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'f' || c >= 'h' && c <= 'z':
goto yystate31
}
yystate158:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'h':
goto yystate154
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'g' || c >= 'i' && c <= 'z':
goto yystate31
}
yystate159:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'N' || c == 'n':
goto yystate75
case c == 'f':
goto yystate74
case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'e' || c >= 'g' && c <= 'm' || c >= 'o' && c <= 'z':
goto yystate31
}
yystate160:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'e':
goto yystate161
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z':
goto yystate31
}
yystate161:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'e':
goto yystate162
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z':
goto yystate31
}
yystate162:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'p':
goto yystate163
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'o' || c >= 'q' && c <= 'z':
goto yystate31
}
yystate163:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'i':
goto yystate164
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'h' || c >= 'j' && c <= 'z':
goto yystate31
}
yystate164:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'n':
goto yystate165
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z':
goto yystate31
}
yystate165:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'g':
goto yystate166
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'f' || c >= 'h' && c <= 'z':
goto yystate31
}
yystate166:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == '_':
goto yystate167
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z':
goto yystate31
}
yystate167:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'e':
goto yystate168
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z':
goto yystate31
}
yystate168:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'x':
goto yystate169
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'w' || c == 'y' || c == 'z':
goto yystate31
}
yystate169:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 't':
goto yystate170
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z':
goto yystate31
}
yystate170:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'r':
goto yystate171
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z':
goto yystate31
}
yystate171:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'a':
goto yystate89
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'b' && c <= 'z':
goto yystate31
}
yystate172:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'a':
goto yystate173
case c == 'i':
goto yystate174
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'b' && c <= 'h' || c >= 'j' && c <= 'z':
goto yystate31
}
yystate173:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'x':
goto yystate128
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'w' || c == 'y' || c == 'z':
goto yystate31
}
yystate174:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'n':
goto yystate128
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z':
goto yystate31
}
yystate175:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c == 'f':
goto yystate176
case c == 'n':
goto yystate101
case c == 'r':
goto yystate37
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'e' || c >= 'g' && c <= 'm' || c >= 'o' && c <= 'q' || c >= 's' && c <= 'z':
goto yystate31
}
yystate176:
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
c = lexer.getChar()
switch {
default:
goto yyrule26
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c == ':':
goto yystate27
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c == 'f':
goto yystate177
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'e' || c >= 'g' && c <= 'z':
goto yystate31
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
}
yystate177:
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
c = lexer.getChar()
switch {
default:
goto yyrule26
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c == ':':
goto yystate27
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c == 's':
goto yystate178
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'r' || c >= 't' && c <= 'z':
goto yystate31
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
}
yystate178:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'e':
goto yystate179
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z':
goto yystate31
}
yystate179:
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
c = lexer.getChar()
switch {
default:
goto yyrule26
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c == ':':
goto yystate27
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c == 't':
goto yystate100
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z':
goto yystate31
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
}
yystate180:
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
c = lexer.getChar()
switch {
default:
goto yyrule26
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c == ':':
goto yystate27
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c == 'e':
goto yystate181
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z':
goto yystate31
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
}
yystate181:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'r':
goto yystate182
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z':
goto yystate31
}
yystate182:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'm':
goto yystate183
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'l' || c >= 'n' && c <= 'z':
goto yystate31
}
yystate183:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'a':
goto yystate184
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'b' && c <= 'z':
goto yystate31
}
yystate184:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'n':
goto yystate185
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z':
goto yystate31
}
yystate185:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'e':
goto yystate186
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z':
goto yystate31
}
yystate186:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'n':
goto yystate187
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z':
goto yystate31
}
yystate187:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 't':
goto yystate110
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z':
goto yystate31
}
yystate188:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'u':
goto yystate189
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 't' || c >= 'v' && c <= 'z':
goto yystate31
}
yystate189:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'm':
goto yystate190
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'l' || c >= 'n' && c <= 'z':
goto yystate31
}
yystate190:
c = lexer.getChar()
switch {
default:
goto yyrule19
case c == ':':
goto yystate27
case c == 'm':
goto yystate191
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'l' || c >= 'n' && c <= 'z':
goto yystate31
}
yystate191:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'a':
goto yystate192
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'b' && c <= 'z':
goto yystate31
}
yystate192:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'r':
goto yystate193
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z':
goto yystate31
}
yystate193:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'y':
goto yystate117
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'x' || c == 'z':
goto yystate31
}
yystate194:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'i':
goto yystate195
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'h' || c >= 'j' && c <= 'z':
goto yystate31
}
yystate195:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 't':
goto yystate196
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z':
goto yystate31
}
yystate196:
c = lexer.getChar()
switch {
default:
goto yyrule26
case c == ':':
goto yystate27
case c == 'h':
goto yystate121
case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'g' || c >= 'i' && c <= 'z':
goto yystate31
}
goto yystate197 // silence unused label error
yystate197:
c = lexer.getChar()
yystart197:
switch {
default:
goto yyabort
case c == '*':
goto yystate199
case c >= '\x01' && c <= ')' || c >= '+' && c <= 'ÿ':
goto yystate198
}
yystate198:
c = lexer.getChar()
goto yyrule3
yystate199:
c = lexer.getChar()
switch {
default:
goto yyrule3
case c == '/':
goto yystate200
}
yystate200:
c = lexer.getChar()
goto yyrule2
yyrule1: // "/*"
{
currentState = S_COMMENTS
goto yystate0
}
yyrule2: // "*/"
{
currentState = S_INITIAL
goto yystate0
}
yyrule3: // .|\n
{
/* ignore chars within multi-line comments */
goto yystate0
}
yyrule4: // \/\/[^\r\n]*\n
{
/* gobble up one-line comments */
goto yystate0
}
yyrule5: // ALERT|alert
{
return ALERT
}
yyrule6: // IF|if
{
return IF
}
yyrule7: // FOR|for
{
return FOR
}
yyrule8: // WITH|with
{
return WITH
}
yyrule9: // SUMMARY|summary
{
return SUMMARY
}
yyrule10: // DESCRIPTION|description
{
return DESCRIPTION
}
yyrule11: // PERMANENT|permanent
{
return PERMANENT
}
yyrule12: // BY|by
{
return GROUP_OP
}
yyrule13: // ON|on
{
return MATCH_OP
}
yyrule14: // GROUP_LEFT|GROUP_RIGHT
{
lval.str = lexer.token()
return MATCH_MOD
goto yystate0
}
yyrule15: // group_left|group_right
{
lval.str = strings.ToUpper(lexer.token())
return MATCH_MOD
goto yystate0
}
yyrule16: // KEEPING_EXTRA|keeping_extra
{
return KEEPING_EXTRA
}
yyrule17: // OFFSET|offset
Implement offset operator. This allows changing the time offset for individual instant and range vectors in a query. For example, this returns the value of `foo` 5 minutes in the past relative to the current query evaluation time: foo offset 5m Note that the `offset` modifier always needs to follow the selector immediately. I.e. the following would be correct: sum(foo offset 5m) // GOOD. While the following would be *incorrect*: sum(foo) offset 5m // INVALID. The same works for range vectors. This returns the 5-minutes-rate that `foo` had a week ago: rate(foo[5m] offset 1w) This change touches the following components: * Lexer/parser: additions to correctly parse the new `offset`/`OFFSET` keyword. * AST: vector and matrix nodes now have an additional `offset` field. This is used during their evaluation to adjust query and result times appropriately. * Query analyzer: now works on separate sets of ranges and instants per offset. Isolating different offsets from each other completely in this way keeps the preloading code relatively simple. No storage engine changes were needed by this change. The rules tests have been changed to not probe the internal implementation details of the query analyzer anymore (how many instants and ranges have been preloaded). This would also become too cumbersome to test with the new model, and measuring the result of the query should be sufficient. This fixes https://github.com/prometheus/prometheus/issues/529 This fixed https://github.com/prometheus/promdash/issues/201
2015-02-17 17:30:41 -08:00
{
return OFFSET
}
yyrule18: // AVG|SUM|MAX|MIN|COUNT
{
lval.str = lexer.token()
return AGGR_OP
goto yystate0
}
yyrule19: // avg|sum|max|min|count
{
lval.str = strings.ToUpper(lexer.token())
return AGGR_OP
goto yystate0
}
yyrule20: // \<|>|AND|OR|and|or
{
lval.str = strings.ToUpper(lexer.token())
return CMP_OP
goto yystate0
}
yyrule21: // ==|!=|>=|<=|=~|!~
{
lval.str = lexer.token()
return CMP_OP
goto yystate0
}
yyrule22: // [+\-]
{
lval.str = lexer.token()
return ADDITIVE_OP
goto yystate0
}
yyrule23: // [*/%]
{
lval.str = lexer.token()
return MULT_OP
goto yystate0
}
yyrule24: // {FLOAT}
{
num, err := strconv.ParseFloat(lexer.token(), 64)
if err != nil && err.(*strconv.NumError).Err == strconv.ErrSyntax {
panic("Invalid float")
}
lval.num = clientmodel.SampleValue(num)
return NUMBER
}
yyrule25: // {D}+{U}
{
lval.str = lexer.token()
return DURATION
goto yystate0
}
yyrule26: // {L}({L}|{D})*
{
lval.str = lexer.token()
return IDENTIFIER
goto yystate0
}
yyrule27: // {M}({M}|{D})*
{
lval.str = lexer.token()
return METRICNAME
goto yystate0
}
yyrule28: // {STR}
{
lval.str = lexer.token()[1 : len(lexer.token())-1]
return STRING
goto yystate0
}
yyrule29: // [{}\[\]()=,]
{
return int(lexer.buf[0])
}
yyrule30: // [\t\n\r ]
{
/* gobble up any whitespace */
goto yystate0
}
panic("unreachable")
goto yyabort // silence unused label error
yyabort: // no lexem recognized
lexer.empty = true
return int(c)
}