ee17941f7f
as we are a Go library is this the much more natural way to express such queries. support for strings is still supported through json marshal and unmarshal, as well as inside query string queries as before we use the package level QueryDateTimeParser to deterimine which date time parser to use for parsing only serializing out to json, we consult a new package variable: QueryDateTimeFormat this addresses the longstanding PR #255
774 lines
16 KiB
Go
774 lines
16 KiB
Go
package query
|
|
|
|
import __yyfmt__ "fmt"
|
|
|
|
//line query_string.y:2
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
func logDebugGrammar(format string, v ...interface{}) {
|
|
if debugParser {
|
|
logger.Printf(format, v...)
|
|
}
|
|
}
|
|
|
|
//line query_string.y:17
|
|
type yySymType struct {
|
|
yys int
|
|
s string
|
|
n int
|
|
f float64
|
|
q Query
|
|
pf *float64
|
|
}
|
|
|
|
const tSTRING = 57346
|
|
const tPHRASE = 57347
|
|
const tPLUS = 57348
|
|
const tMINUS = 57349
|
|
const tCOLON = 57350
|
|
const tBOOST = 57351
|
|
const tNUMBER = 57352
|
|
const tGREATER = 57353
|
|
const tLESS = 57354
|
|
const tEQUAL = 57355
|
|
const tTILDE = 57356
|
|
|
|
var yyToknames = [...]string{
|
|
"$end",
|
|
"error",
|
|
"$unk",
|
|
"tSTRING",
|
|
"tPHRASE",
|
|
"tPLUS",
|
|
"tMINUS",
|
|
"tCOLON",
|
|
"tBOOST",
|
|
"tNUMBER",
|
|
"tGREATER",
|
|
"tLESS",
|
|
"tEQUAL",
|
|
"tTILDE",
|
|
}
|
|
var yyStatenames = [...]string{}
|
|
|
|
const yyEofCode = 1
|
|
const yyErrCode = 2
|
|
const yyInitialStackSize = 16
|
|
|
|
//line yacctab:1
|
|
var yyExca = [...]int{
|
|
-1, 1,
|
|
1, -1,
|
|
-2, 0,
|
|
-1, 3,
|
|
1, 3,
|
|
-2, 5,
|
|
}
|
|
|
|
const yyNprod = 26
|
|
const yyPrivate = 57344
|
|
|
|
var yyTokenNames []string
|
|
var yyStates []string
|
|
|
|
const yyLast = 31
|
|
|
|
var yyAct = [...]int{
|
|
|
|
16, 18, 21, 13, 27, 24, 17, 19, 20, 25,
|
|
22, 15, 26, 23, 9, 11, 31, 14, 29, 3,
|
|
10, 30, 2, 28, 5, 6, 7, 1, 4, 12,
|
|
8,
|
|
}
|
|
var yyPact = [...]int{
|
|
|
|
18, -1000, -1000, 18, 10, -1000, -1000, -1000, -6, 3,
|
|
-1000, -1000, -1000, -1000, -1000, -4, -12, -1000, -1000, 0,
|
|
-1, -1000, -1000, 13, -1000, -1000, 11, -1000, -1000, -1000,
|
|
-1000, -1000,
|
|
}
|
|
var yyPgo = [...]int{
|
|
|
|
0, 30, 29, 28, 27, 22, 19,
|
|
}
|
|
var yyR1 = [...]int{
|
|
|
|
0, 4, 5, 5, 6, 3, 3, 3, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 2, 2,
|
|
}
|
|
var yyR2 = [...]int{
|
|
|
|
0, 1, 2, 1, 3, 0, 1, 1, 1, 2,
|
|
4, 1, 1, 3, 3, 3, 4, 5, 4, 5,
|
|
4, 5, 4, 5, 0, 1,
|
|
}
|
|
var yyChk = [...]int{
|
|
|
|
-1000, -4, -5, -6, -3, 6, 7, -5, -1, 4,
|
|
10, 5, -2, 9, 14, 8, 4, 10, 5, 11,
|
|
12, 14, 10, 13, 5, 10, 13, 5, 10, 5,
|
|
10, 5,
|
|
}
|
|
var yyDef = [...]int{
|
|
|
|
5, -2, 1, -2, 0, 6, 7, 2, 24, 8,
|
|
11, 12, 4, 25, 9, 0, 13, 14, 15, 0,
|
|
0, 10, 16, 0, 20, 18, 0, 22, 17, 21,
|
|
19, 23,
|
|
}
|
|
var yyTok1 = [...]int{
|
|
|
|
1,
|
|
}
|
|
var yyTok2 = [...]int{
|
|
|
|
2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
|
|
12, 13, 14,
|
|
}
|
|
var yyTok3 = [...]int{
|
|
0,
|
|
}
|
|
|
|
var yyErrorMessages = [...]struct {
|
|
state int
|
|
token int
|
|
msg string
|
|
}{}
|
|
|
|
//line yaccpar:1
|
|
|
|
/* parser for yacc output */
|
|
|
|
var (
|
|
yyDebug = 0
|
|
yyErrorVerbose = false
|
|
)
|
|
|
|
type yyLexer interface {
|
|
Lex(lval *yySymType) int
|
|
Error(s string)
|
|
}
|
|
|
|
type yyParser interface {
|
|
Parse(yyLexer) int
|
|
Lookahead() int
|
|
}
|
|
|
|
type yyParserImpl struct {
|
|
lval yySymType
|
|
stack [yyInitialStackSize]yySymType
|
|
char int
|
|
}
|
|
|
|
func (p *yyParserImpl) Lookahead() int {
|
|
return p.char
|
|
}
|
|
|
|
func yyNewParser() yyParser {
|
|
return &yyParserImpl{}
|
|
}
|
|
|
|
const yyFlag = -1000
|
|
|
|
func yyTokname(c int) string {
|
|
if c >= 1 && c-1 < len(yyToknames) {
|
|
if yyToknames[c-1] != "" {
|
|
return yyToknames[c-1]
|
|
}
|
|
}
|
|
return __yyfmt__.Sprintf("tok-%v", c)
|
|
}
|
|
|
|
func yyStatname(s int) string {
|
|
if s >= 0 && s < len(yyStatenames) {
|
|
if yyStatenames[s] != "" {
|
|
return yyStatenames[s]
|
|
}
|
|
}
|
|
return __yyfmt__.Sprintf("state-%v", s)
|
|
}
|
|
|
|
func yyErrorMessage(state, lookAhead int) string {
|
|
const TOKSTART = 4
|
|
|
|
if !yyErrorVerbose {
|
|
return "syntax error"
|
|
}
|
|
|
|
for _, e := range yyErrorMessages {
|
|
if e.state == state && e.token == lookAhead {
|
|
return "syntax error: " + e.msg
|
|
}
|
|
}
|
|
|
|
res := "syntax error: unexpected " + yyTokname(lookAhead)
|
|
|
|
// To match Bison, suggest at most four expected tokens.
|
|
expected := make([]int, 0, 4)
|
|
|
|
// Look for shiftable tokens.
|
|
base := yyPact[state]
|
|
for tok := TOKSTART; tok-1 < len(yyToknames); tok++ {
|
|
if n := base + tok; n >= 0 && n < yyLast && yyChk[yyAct[n]] == tok {
|
|
if len(expected) == cap(expected) {
|
|
return res
|
|
}
|
|
expected = append(expected, tok)
|
|
}
|
|
}
|
|
|
|
if yyDef[state] == -2 {
|
|
i := 0
|
|
for yyExca[i] != -1 || yyExca[i+1] != state {
|
|
i += 2
|
|
}
|
|
|
|
// Look for tokens that we accept or reduce.
|
|
for i += 2; yyExca[i] >= 0; i += 2 {
|
|
tok := yyExca[i]
|
|
if tok < TOKSTART || yyExca[i+1] == 0 {
|
|
continue
|
|
}
|
|
if len(expected) == cap(expected) {
|
|
return res
|
|
}
|
|
expected = append(expected, tok)
|
|
}
|
|
|
|
// If the default action is to accept or reduce, give up.
|
|
if yyExca[i+1] != 0 {
|
|
return res
|
|
}
|
|
}
|
|
|
|
for i, tok := range expected {
|
|
if i == 0 {
|
|
res += ", expecting "
|
|
} else {
|
|
res += " or "
|
|
}
|
|
res += yyTokname(tok)
|
|
}
|
|
return res
|
|
}
|
|
|
|
func yylex1(lex yyLexer, lval *yySymType) (char, token int) {
|
|
token = 0
|
|
char = lex.Lex(lval)
|
|
if char <= 0 {
|
|
token = yyTok1[0]
|
|
goto out
|
|
}
|
|
if char < len(yyTok1) {
|
|
token = yyTok1[char]
|
|
goto out
|
|
}
|
|
if char >= yyPrivate {
|
|
if char < yyPrivate+len(yyTok2) {
|
|
token = yyTok2[char-yyPrivate]
|
|
goto out
|
|
}
|
|
}
|
|
for i := 0; i < len(yyTok3); i += 2 {
|
|
token = yyTok3[i+0]
|
|
if token == char {
|
|
token = yyTok3[i+1]
|
|
goto out
|
|
}
|
|
}
|
|
|
|
out:
|
|
if token == 0 {
|
|
token = yyTok2[1] /* unknown char */
|
|
}
|
|
if yyDebug >= 3 {
|
|
__yyfmt__.Printf("lex %s(%d)\n", yyTokname(token), uint(char))
|
|
}
|
|
return char, token
|
|
}
|
|
|
|
func yyParse(yylex yyLexer) int {
|
|
return yyNewParser().Parse(yylex)
|
|
}
|
|
|
|
func (yyrcvr *yyParserImpl) Parse(yylex yyLexer) int {
|
|
var yyn int
|
|
var yyVAL yySymType
|
|
var yyDollar []yySymType
|
|
_ = yyDollar // silence set and not used
|
|
yyS := yyrcvr.stack[:]
|
|
|
|
Nerrs := 0 /* number of errors */
|
|
Errflag := 0 /* error recovery flag */
|
|
yystate := 0
|
|
yyrcvr.char = -1
|
|
yytoken := -1 // yyrcvr.char translated into internal numbering
|
|
defer func() {
|
|
// Make sure we report no lookahead when not parsing.
|
|
yystate = -1
|
|
yyrcvr.char = -1
|
|
yytoken = -1
|
|
}()
|
|
yyp := -1
|
|
goto yystack
|
|
|
|
ret0:
|
|
return 0
|
|
|
|
ret1:
|
|
return 1
|
|
|
|
yystack:
|
|
/* put a state and value onto the stack */
|
|
if yyDebug >= 4 {
|
|
__yyfmt__.Printf("char %v in %v\n", yyTokname(yytoken), yyStatname(yystate))
|
|
}
|
|
|
|
yyp++
|
|
if yyp >= len(yyS) {
|
|
nyys := make([]yySymType, len(yyS)*2)
|
|
copy(nyys, yyS)
|
|
yyS = nyys
|
|
}
|
|
yyS[yyp] = yyVAL
|
|
yyS[yyp].yys = yystate
|
|
|
|
yynewstate:
|
|
yyn = yyPact[yystate]
|
|
if yyn <= yyFlag {
|
|
goto yydefault /* simple state */
|
|
}
|
|
if yyrcvr.char < 0 {
|
|
yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval)
|
|
}
|
|
yyn += yytoken
|
|
if yyn < 0 || yyn >= yyLast {
|
|
goto yydefault
|
|
}
|
|
yyn = yyAct[yyn]
|
|
if yyChk[yyn] == yytoken { /* valid shift */
|
|
yyrcvr.char = -1
|
|
yytoken = -1
|
|
yyVAL = yyrcvr.lval
|
|
yystate = yyn
|
|
if Errflag > 0 {
|
|
Errflag--
|
|
}
|
|
goto yystack
|
|
}
|
|
|
|
yydefault:
|
|
/* default state action */
|
|
yyn = yyDef[yystate]
|
|
if yyn == -2 {
|
|
if yyrcvr.char < 0 {
|
|
yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval)
|
|
}
|
|
|
|
/* look through exception table */
|
|
xi := 0
|
|
for {
|
|
if yyExca[xi+0] == -1 && yyExca[xi+1] == yystate {
|
|
break
|
|
}
|
|
xi += 2
|
|
}
|
|
for xi += 2; ; xi += 2 {
|
|
yyn = yyExca[xi+0]
|
|
if yyn < 0 || yyn == yytoken {
|
|
break
|
|
}
|
|
}
|
|
yyn = yyExca[xi+1]
|
|
if yyn < 0 {
|
|
goto ret0
|
|
}
|
|
}
|
|
if yyn == 0 {
|
|
/* error ... attempt to resume parsing */
|
|
switch Errflag {
|
|
case 0: /* brand new error */
|
|
yylex.Error(yyErrorMessage(yystate, yytoken))
|
|
Nerrs++
|
|
if yyDebug >= 1 {
|
|
__yyfmt__.Printf("%s", yyStatname(yystate))
|
|
__yyfmt__.Printf(" saw %s\n", yyTokname(yytoken))
|
|
}
|
|
fallthrough
|
|
|
|
case 1, 2: /* incompletely recovered error ... try again */
|
|
Errflag = 3
|
|
|
|
/* find a state where "error" is a legal shift action */
|
|
for yyp >= 0 {
|
|
yyn = yyPact[yyS[yyp].yys] + yyErrCode
|
|
if yyn >= 0 && yyn < yyLast {
|
|
yystate = yyAct[yyn] /* simulate a shift of "error" */
|
|
if yyChk[yystate] == yyErrCode {
|
|
goto yystack
|
|
}
|
|
}
|
|
|
|
/* the current p has no shift on "error", pop stack */
|
|
if yyDebug >= 2 {
|
|
__yyfmt__.Printf("error recovery pops state %d\n", yyS[yyp].yys)
|
|
}
|
|
yyp--
|
|
}
|
|
/* there is no state on the stack with an error shift ... abort */
|
|
goto ret1
|
|
|
|
case 3: /* no shift yet; clobber input char */
|
|
if yyDebug >= 2 {
|
|
__yyfmt__.Printf("error recovery discards %s\n", yyTokname(yytoken))
|
|
}
|
|
if yytoken == yyEofCode {
|
|
goto ret1
|
|
}
|
|
yyrcvr.char = -1
|
|
yytoken = -1
|
|
goto yynewstate /* try again in the same state */
|
|
}
|
|
}
|
|
|
|
/* reduction by production yyn */
|
|
if yyDebug >= 2 {
|
|
__yyfmt__.Printf("reduce %v in:\n\t%v\n", yyn, yyStatname(yystate))
|
|
}
|
|
|
|
yynt := yyn
|
|
yypt := yyp
|
|
_ = yypt // guard against "declared and not used"
|
|
|
|
yyp -= yyR2[yyn]
|
|
// yyp is now the index of $0. Perform the default action. Iff the
|
|
// reduced production is ε, $1 is possibly out of range.
|
|
if yyp+1 >= len(yyS) {
|
|
nyys := make([]yySymType, len(yyS)*2)
|
|
copy(nyys, yyS)
|
|
yyS = nyys
|
|
}
|
|
yyVAL = yyS[yyp+1]
|
|
|
|
/* consult goto table to find next state */
|
|
yyn = yyR1[yyn]
|
|
yyg := yyPgo[yyn]
|
|
yyj := yyg + yyS[yyp].yys + 1
|
|
|
|
if yyj >= yyLast {
|
|
yystate = yyAct[yyg]
|
|
} else {
|
|
yystate = yyAct[yyj]
|
|
if yyChk[yystate] != -yyn {
|
|
yystate = yyAct[yyg]
|
|
}
|
|
}
|
|
// dummy call; replaced with literal code
|
|
switch yynt {
|
|
|
|
case 1:
|
|
yyDollar = yyS[yypt-1 : yypt+1]
|
|
//line query_string.y:39
|
|
{
|
|
logDebugGrammar("INPUT")
|
|
}
|
|
case 2:
|
|
yyDollar = yyS[yypt-2 : yypt+1]
|
|
//line query_string.y:44
|
|
{
|
|
logDebugGrammar("SEARCH PARTS")
|
|
}
|
|
case 3:
|
|
yyDollar = yyS[yypt-1 : yypt+1]
|
|
//line query_string.y:48
|
|
{
|
|
logDebugGrammar("SEARCH PART")
|
|
}
|
|
case 4:
|
|
yyDollar = yyS[yypt-3 : yypt+1]
|
|
//line query_string.y:53
|
|
{
|
|
query := yyDollar[2].q
|
|
if yyDollar[3].pf != nil {
|
|
if query, ok := query.(BoostableQuery); ok {
|
|
query.SetBoost(*yyDollar[3].pf)
|
|
}
|
|
}
|
|
switch yyDollar[1].n {
|
|
case queryShould:
|
|
yylex.(*lexerWrapper).query.AddShould(query)
|
|
case queryMust:
|
|
yylex.(*lexerWrapper).query.AddMust(query)
|
|
case queryMustNot:
|
|
yylex.(*lexerWrapper).query.AddMustNot(query)
|
|
}
|
|
}
|
|
case 5:
|
|
yyDollar = yyS[yypt-0 : yypt+1]
|
|
//line query_string.y:72
|
|
{
|
|
yyVAL.n = queryShould
|
|
}
|
|
case 6:
|
|
yyDollar = yyS[yypt-1 : yypt+1]
|
|
//line query_string.y:76
|
|
{
|
|
logDebugGrammar("PLUS")
|
|
yyVAL.n = queryMust
|
|
}
|
|
case 7:
|
|
yyDollar = yyS[yypt-1 : yypt+1]
|
|
//line query_string.y:81
|
|
{
|
|
logDebugGrammar("MINUS")
|
|
yyVAL.n = queryMustNot
|
|
}
|
|
case 8:
|
|
yyDollar = yyS[yypt-1 : yypt+1]
|
|
//line query_string.y:87
|
|
{
|
|
str := yyDollar[1].s
|
|
logDebugGrammar("STRING - %s", str)
|
|
var q FieldableQuery
|
|
if strings.HasPrefix(str, "/") && strings.HasSuffix(str, "/") {
|
|
q = NewRegexpQuery(str[1 : len(str)-1])
|
|
} else if strings.ContainsAny(str, "*?") {
|
|
q = NewWildcardQuery(str)
|
|
} else {
|
|
q = NewMatchQuery(str)
|
|
}
|
|
yyVAL.q = q
|
|
}
|
|
case 9:
|
|
yyDollar = yyS[yypt-2 : yypt+1]
|
|
//line query_string.y:101
|
|
{
|
|
str := yyDollar[1].s
|
|
fuzziness, err := strconv.ParseFloat(yyDollar[2].s, 64)
|
|
if err != nil {
|
|
yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid fuzziness value: %v", err))
|
|
}
|
|
logDebugGrammar("FUZZY STRING - %s %f", str, fuzziness)
|
|
q := NewMatchQuery(str)
|
|
q.SetFuzziness(int(fuzziness))
|
|
yyVAL.q = q
|
|
}
|
|
case 10:
|
|
yyDollar = yyS[yypt-4 : yypt+1]
|
|
//line query_string.y:113
|
|
{
|
|
field := yyDollar[1].s
|
|
str := yyDollar[3].s
|
|
fuzziness, err := strconv.ParseFloat(yyDollar[4].s, 64)
|
|
if err != nil {
|
|
yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid fuzziness value: %v", err))
|
|
}
|
|
logDebugGrammar("FIELD - %s FUZZY STRING - %s %f", field, str, fuzziness)
|
|
q := NewMatchQuery(str)
|
|
q.SetFuzziness(int(fuzziness))
|
|
q.SetField(field)
|
|
yyVAL.q = q
|
|
}
|
|
case 11:
|
|
yyDollar = yyS[yypt-1 : yypt+1]
|
|
//line query_string.y:127
|
|
{
|
|
str := yyDollar[1].s
|
|
logDebugGrammar("STRING - %s", str)
|
|
q := NewMatchQuery(str)
|
|
yyVAL.q = q
|
|
}
|
|
case 12:
|
|
yyDollar = yyS[yypt-1 : yypt+1]
|
|
//line query_string.y:134
|
|
{
|
|
phrase := yyDollar[1].s
|
|
logDebugGrammar("PHRASE - %s", phrase)
|
|
q := NewMatchPhraseQuery(phrase)
|
|
yyVAL.q = q
|
|
}
|
|
case 13:
|
|
yyDollar = yyS[yypt-3 : yypt+1]
|
|
//line query_string.y:141
|
|
{
|
|
field := yyDollar[1].s
|
|
str := yyDollar[3].s
|
|
logDebugGrammar("FIELD - %s STRING - %s", field, str)
|
|
var q FieldableQuery
|
|
if strings.HasPrefix(str, "/") && strings.HasSuffix(str, "/") {
|
|
q = NewRegexpQuery(str[1 : len(str)-1])
|
|
} else if strings.ContainsAny(str, "*?") {
|
|
q = NewWildcardQuery(str)
|
|
} else {
|
|
q = NewMatchQuery(str)
|
|
}
|
|
q.SetField(field)
|
|
yyVAL.q = q
|
|
}
|
|
case 14:
|
|
yyDollar = yyS[yypt-3 : yypt+1]
|
|
//line query_string.y:157
|
|
{
|
|
field := yyDollar[1].s
|
|
str := yyDollar[3].s
|
|
logDebugGrammar("FIELD - %s STRING - %s", field, str)
|
|
q := NewMatchQuery(str)
|
|
q.SetField(field)
|
|
yyVAL.q = q
|
|
}
|
|
case 15:
|
|
yyDollar = yyS[yypt-3 : yypt+1]
|
|
//line query_string.y:166
|
|
{
|
|
field := yyDollar[1].s
|
|
phrase := yyDollar[3].s
|
|
logDebugGrammar("FIELD - %s PHRASE - %s", field, phrase)
|
|
q := NewMatchPhraseQuery(phrase)
|
|
q.SetField(field)
|
|
yyVAL.q = q
|
|
}
|
|
case 16:
|
|
yyDollar = yyS[yypt-4 : yypt+1]
|
|
//line query_string.y:175
|
|
{
|
|
field := yyDollar[1].s
|
|
min, _ := strconv.ParseFloat(yyDollar[4].s, 64)
|
|
minInclusive := false
|
|
logDebugGrammar("FIELD - GREATER THAN %f", min)
|
|
q := NewNumericRangeInclusiveQuery(&min, nil, &minInclusive, nil)
|
|
q.SetField(field)
|
|
yyVAL.q = q
|
|
}
|
|
case 17:
|
|
yyDollar = yyS[yypt-5 : yypt+1]
|
|
//line query_string.y:185
|
|
{
|
|
field := yyDollar[1].s
|
|
min, _ := strconv.ParseFloat(yyDollar[5].s, 64)
|
|
minInclusive := true
|
|
logDebugGrammar("FIELD - GREATER THAN OR EQUAL %f", min)
|
|
q := NewNumericRangeInclusiveQuery(&min, nil, &minInclusive, nil)
|
|
q.SetField(field)
|
|
yyVAL.q = q
|
|
}
|
|
case 18:
|
|
yyDollar = yyS[yypt-4 : yypt+1]
|
|
//line query_string.y:195
|
|
{
|
|
field := yyDollar[1].s
|
|
max, _ := strconv.ParseFloat(yyDollar[4].s, 64)
|
|
maxInclusive := false
|
|
logDebugGrammar("FIELD - LESS THAN %f", max)
|
|
q := NewNumericRangeInclusiveQuery(nil, &max, nil, &maxInclusive)
|
|
q.SetField(field)
|
|
yyVAL.q = q
|
|
}
|
|
case 19:
|
|
yyDollar = yyS[yypt-5 : yypt+1]
|
|
//line query_string.y:205
|
|
{
|
|
field := yyDollar[1].s
|
|
max, _ := strconv.ParseFloat(yyDollar[5].s, 64)
|
|
maxInclusive := true
|
|
logDebugGrammar("FIELD - LESS THAN OR EQUAL %f", max)
|
|
q := NewNumericRangeInclusiveQuery(nil, &max, nil, &maxInclusive)
|
|
q.SetField(field)
|
|
yyVAL.q = q
|
|
}
|
|
case 20:
|
|
yyDollar = yyS[yypt-4 : yypt+1]
|
|
//line query_string.y:215
|
|
{
|
|
field := yyDollar[1].s
|
|
minInclusive := false
|
|
phrase := yyDollar[4].s
|
|
|
|
logDebugGrammar("FIELD - GREATER THAN DATE %s", phrase)
|
|
minTime, err := QueryTimeFromString(phrase)
|
|
if err != nil {
|
|
yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
|
|
}
|
|
q := NewDateRangeInclusiveQuery(minTime, time.Time{}, &minInclusive, nil)
|
|
q.SetField(field)
|
|
yyVAL.q = q
|
|
}
|
|
case 21:
|
|
yyDollar = yyS[yypt-5 : yypt+1]
|
|
//line query_string.y:230
|
|
{
|
|
field := yyDollar[1].s
|
|
minInclusive := true
|
|
phrase := yyDollar[5].s
|
|
|
|
logDebugGrammar("FIELD - GREATER THAN OR EQUAL DATE %s", phrase)
|
|
minTime, err := QueryTimeFromString(phrase)
|
|
if err != nil {
|
|
yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
|
|
}
|
|
q := NewDateRangeInclusiveQuery(minTime, time.Time{}, &minInclusive, nil)
|
|
q.SetField(field)
|
|
yyVAL.q = q
|
|
}
|
|
case 22:
|
|
yyDollar = yyS[yypt-4 : yypt+1]
|
|
//line query_string.y:245
|
|
{
|
|
field := yyDollar[1].s
|
|
maxInclusive := false
|
|
phrase := yyDollar[4].s
|
|
|
|
logDebugGrammar("FIELD - LESS THAN DATE %s", phrase)
|
|
maxTime, err := QueryTimeFromString(phrase)
|
|
if err != nil {
|
|
yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
|
|
}
|
|
q := NewDateRangeInclusiveQuery(time.Time{}, maxTime, nil, &maxInclusive)
|
|
q.SetField(field)
|
|
yyVAL.q = q
|
|
}
|
|
case 23:
|
|
yyDollar = yyS[yypt-5 : yypt+1]
|
|
//line query_string.y:260
|
|
{
|
|
field := yyDollar[1].s
|
|
maxInclusive := true
|
|
phrase := yyDollar[5].s
|
|
|
|
logDebugGrammar("FIELD - LESS THAN OR EQUAL DATE %s", phrase)
|
|
maxTime, err := QueryTimeFromString(phrase)
|
|
if err != nil {
|
|
yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
|
|
}
|
|
q := NewDateRangeInclusiveQuery(time.Time{}, maxTime, nil, &maxInclusive)
|
|
q.SetField(field)
|
|
yyVAL.q = q
|
|
}
|
|
case 24:
|
|
yyDollar = yyS[yypt-0 : yypt+1]
|
|
//line query_string.y:276
|
|
{
|
|
yyVAL.pf = nil
|
|
}
|
|
case 25:
|
|
yyDollar = yyS[yypt-1 : yypt+1]
|
|
//line query_string.y:280
|
|
{
|
|
yyVAL.pf = nil
|
|
boost, err := strconv.ParseFloat(yyDollar[1].s, 64)
|
|
if err != nil {
|
|
yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid boost value: %v", err))
|
|
} else {
|
|
yyVAL.pf = &boost
|
|
}
|
|
logDebugGrammar("BOOST %f", boost)
|
|
}
|
|
}
|
|
goto yystack /* stack new state and value */
|
|
}
|