1package query
2
3import __yyfmt__ "fmt"
4
5//line query_string.y:2
6import (
7	"fmt"
8	"strconv"
9	"strings"
10	"time"
11)
12
13func logDebugGrammar(format string, v ...interface{}) {
14	if debugParser {
15		logger.Printf(format, v...)
16	}
17}
18
19//line query_string.y:17
20type yySymType struct {
21	yys int
22	s   string
23	n   int
24	f   float64
25	q   Query
26	pf  *float64
27}
28
29const tSTRING = 57346
30const tPHRASE = 57347
31const tPLUS = 57348
32const tMINUS = 57349
33const tCOLON = 57350
34const tBOOST = 57351
35const tNUMBER = 57352
36const tGREATER = 57353
37const tLESS = 57354
38const tEQUAL = 57355
39const tTILDE = 57356
40
41var yyToknames = [...]string{
42	"$end",
43	"error",
44	"$unk",
45	"tSTRING",
46	"tPHRASE",
47	"tPLUS",
48	"tMINUS",
49	"tCOLON",
50	"tBOOST",
51	"tNUMBER",
52	"tGREATER",
53	"tLESS",
54	"tEQUAL",
55	"tTILDE",
56}
57var yyStatenames = [...]string{}
58
59const yyEofCode = 1
60const yyErrCode = 2
61const yyInitialStackSize = 16
62
63//line yacctab:1
64var yyExca = [...]int{
65	-1, 1,
66	1, -1,
67	-2, 0,
68	-1, 3,
69	1, 3,
70	-2, 5,
71}
72
73const yyNprod = 28
74const yyPrivate = 57344
75
76var yyTokenNames []string
77var yyStates []string
78
79const yyLast = 42
80
81var yyAct = [...]int{
82
83	17, 16, 18, 23, 22, 30, 3, 21, 19, 20,
84	29, 26, 22, 22, 1, 21, 21, 15, 28, 25,
85	24, 27, 34, 14, 22, 13, 31, 21, 32, 33,
86	22, 9, 11, 21, 5, 6, 2, 10, 4, 12,
87	7, 8,
88}
89var yyPact = [...]int{
90
91	28, -1000, -1000, 28, 27, -1000, -1000, -1000, 16, 9,
92	-1000, -1000, -1000, -1000, -1000, -3, -11, -1000, -1000, 6,
93	5, -1000, -5, -1000, -1000, 23, -1000, -1000, 17, -1000,
94	-1000, -1000, -1000, -1000, -1000,
95}
96var yyPgo = [...]int{
97
98	0, 0, 41, 39, 38, 14, 36, 6,
99}
100var yyR1 = [...]int{
101
102	0, 5, 6, 6, 7, 4, 4, 4, 2, 2,
103	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
104	2, 2, 2, 2, 3, 3, 1, 1,
105}
106var yyR2 = [...]int{
107
108	0, 1, 2, 1, 3, 0, 1, 1, 1, 2,
109	4, 1, 1, 3, 3, 3, 4, 5, 4, 5,
110	4, 5, 4, 5, 0, 1, 1, 2,
111}
112var yyChk = [...]int{
113
114	-1000, -5, -6, -7, -4, 6, 7, -6, -2, 4,
115	10, 5, -3, 9, 14, 8, 4, -1, 5, 11,
116	12, 10, 7, 14, -1, 13, 5, -1, 13, 5,
117	10, -1, 5, -1, 5,
118}
119var yyDef = [...]int{
120
121	5, -2, 1, -2, 0, 6, 7, 2, 24, 8,
122	11, 12, 4, 25, 9, 0, 13, 14, 15, 0,
123	0, 26, 0, 10, 16, 0, 20, 18, 0, 22,
124	27, 17, 21, 19, 23,
125}
126var yyTok1 = [...]int{
127
128	1,
129}
130var yyTok2 = [...]int{
131
132	2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
133	12, 13, 14,
134}
135var yyTok3 = [...]int{
136	0,
137}
138
139var yyErrorMessages = [...]struct {
140	state int
141	token int
142	msg   string
143}{}
144
145//line yaccpar:1
146
147/*	parser for yacc output	*/
148
149var (
150	yyDebug        = 0
151	yyErrorVerbose = false
152)
153
154type yyLexer interface {
155	Lex(lval *yySymType) int
156	Error(s string)
157}
158
159type yyParser interface {
160	Parse(yyLexer) int
161	Lookahead() int
162}
163
164type yyParserImpl struct {
165	lval  yySymType
166	stack [yyInitialStackSize]yySymType
167	char  int
168}
169
170func (p *yyParserImpl) Lookahead() int {
171	return p.char
172}
173
174func yyNewParser() yyParser {
175	return &yyParserImpl{}
176}
177
178const yyFlag = -1000
179
180func yyTokname(c int) string {
181	if c >= 1 && c-1 < len(yyToknames) {
182		if yyToknames[c-1] != "" {
183			return yyToknames[c-1]
184		}
185	}
186	return __yyfmt__.Sprintf("tok-%v", c)
187}
188
189func yyStatname(s int) string {
190	if s >= 0 && s < len(yyStatenames) {
191		if yyStatenames[s] != "" {
192			return yyStatenames[s]
193		}
194	}
195	return __yyfmt__.Sprintf("state-%v", s)
196}
197
198func yyErrorMessage(state, lookAhead int) string {
199	const TOKSTART = 4
200
201	if !yyErrorVerbose {
202		return "syntax error"
203	}
204
205	for _, e := range yyErrorMessages {
206		if e.state == state && e.token == lookAhead {
207			return "syntax error: " + e.msg
208		}
209	}
210
211	res := "syntax error: unexpected " + yyTokname(lookAhead)
212
213	// To match Bison, suggest at most four expected tokens.
214	expected := make([]int, 0, 4)
215
216	// Look for shiftable tokens.
217	base := yyPact[state]
218	for tok := TOKSTART; tok-1 < len(yyToknames); tok++ {
219		if n := base + tok; n >= 0 && n < yyLast && yyChk[yyAct[n]] == tok {
220			if len(expected) == cap(expected) {
221				return res
222			}
223			expected = append(expected, tok)
224		}
225	}
226
227	if yyDef[state] == -2 {
228		i := 0
229		for yyExca[i] != -1 || yyExca[i+1] != state {
230			i += 2
231		}
232
233		// Look for tokens that we accept or reduce.
234		for i += 2; yyExca[i] >= 0; i += 2 {
235			tok := yyExca[i]
236			if tok < TOKSTART || yyExca[i+1] == 0 {
237				continue
238			}
239			if len(expected) == cap(expected) {
240				return res
241			}
242			expected = append(expected, tok)
243		}
244
245		// If the default action is to accept or reduce, give up.
246		if yyExca[i+1] != 0 {
247			return res
248		}
249	}
250
251	for i, tok := range expected {
252		if i == 0 {
253			res += ", expecting "
254		} else {
255			res += " or "
256		}
257		res += yyTokname(tok)
258	}
259	return res
260}
261
262func yylex1(lex yyLexer, lval *yySymType) (char, token int) {
263	token = 0
264	char = lex.Lex(lval)
265	if char <= 0 {
266		token = yyTok1[0]
267		goto out
268	}
269	if char < len(yyTok1) {
270		token = yyTok1[char]
271		goto out
272	}
273	if char >= yyPrivate {
274		if char < yyPrivate+len(yyTok2) {
275			token = yyTok2[char-yyPrivate]
276			goto out
277		}
278	}
279	for i := 0; i < len(yyTok3); i += 2 {
280		token = yyTok3[i+0]
281		if token == char {
282			token = yyTok3[i+1]
283			goto out
284		}
285	}
286
287out:
288	if token == 0 {
289		token = yyTok2[1] /* unknown char */
290	}
291	if yyDebug >= 3 {
292		__yyfmt__.Printf("lex %s(%d)\n", yyTokname(token), uint(char))
293	}
294	return char, token
295}
296
297func yyParse(yylex yyLexer) int {
298	return yyNewParser().Parse(yylex)
299}
300
301func (yyrcvr *yyParserImpl) Parse(yylex yyLexer) int {
302	var yyn int
303	var yyVAL yySymType
304	var yyDollar []yySymType
305	_ = yyDollar // silence set and not used
306	yyS := yyrcvr.stack[:]
307
308	Nerrs := 0   /* number of errors */
309	Errflag := 0 /* error recovery flag */
310	yystate := 0
311	yyrcvr.char = -1
312	yytoken := -1 // yyrcvr.char translated into internal numbering
313	defer func() {
314		// Make sure we report no lookahead when not parsing.
315		yystate = -1
316		yyrcvr.char = -1
317		yytoken = -1
318	}()
319	yyp := -1
320	goto yystack
321
322ret0:
323	return 0
324
325ret1:
326	return 1
327
328yystack:
329	/* put a state and value onto the stack */
330	if yyDebug >= 4 {
331		__yyfmt__.Printf("char %v in %v\n", yyTokname(yytoken), yyStatname(yystate))
332	}
333
334	yyp++
335	if yyp >= len(yyS) {
336		nyys := make([]yySymType, len(yyS)*2)
337		copy(nyys, yyS)
338		yyS = nyys
339	}
340	yyS[yyp] = yyVAL
341	yyS[yyp].yys = yystate
342
343yynewstate:
344	yyn = yyPact[yystate]
345	if yyn <= yyFlag {
346		goto yydefault /* simple state */
347	}
348	if yyrcvr.char < 0 {
349		yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval)
350	}
351	yyn += yytoken
352	if yyn < 0 || yyn >= yyLast {
353		goto yydefault
354	}
355	yyn = yyAct[yyn]
356	if yyChk[yyn] == yytoken { /* valid shift */
357		yyrcvr.char = -1
358		yytoken = -1
359		yyVAL = yyrcvr.lval
360		yystate = yyn
361		if Errflag > 0 {
362			Errflag--
363		}
364		goto yystack
365	}
366
367yydefault:
368	/* default state action */
369	yyn = yyDef[yystate]
370	if yyn == -2 {
371		if yyrcvr.char < 0 {
372			yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval)
373		}
374
375		/* look through exception table */
376		xi := 0
377		for {
378			if yyExca[xi+0] == -1 && yyExca[xi+1] == yystate {
379				break
380			}
381			xi += 2
382		}
383		for xi += 2; ; xi += 2 {
384			yyn = yyExca[xi+0]
385			if yyn < 0 || yyn == yytoken {
386				break
387			}
388		}
389		yyn = yyExca[xi+1]
390		if yyn < 0 {
391			goto ret0
392		}
393	}
394	if yyn == 0 {
395		/* error ... attempt to resume parsing */
396		switch Errflag {
397		case 0: /* brand new error */
398			yylex.Error(yyErrorMessage(yystate, yytoken))
399			Nerrs++
400			if yyDebug >= 1 {
401				__yyfmt__.Printf("%s", yyStatname(yystate))
402				__yyfmt__.Printf(" saw %s\n", yyTokname(yytoken))
403			}
404			fallthrough
405
406		case 1, 2: /* incompletely recovered error ... try again */
407			Errflag = 3
408
409			/* find a state where "error" is a legal shift action */
410			for yyp >= 0 {
411				yyn = yyPact[yyS[yyp].yys] + yyErrCode
412				if yyn >= 0 && yyn < yyLast {
413					yystate = yyAct[yyn] /* simulate a shift of "error" */
414					if yyChk[yystate] == yyErrCode {
415						goto yystack
416					}
417				}
418
419				/* the current p has no shift on "error", pop stack */
420				if yyDebug >= 2 {
421					__yyfmt__.Printf("error recovery pops state %d\n", yyS[yyp].yys)
422				}
423				yyp--
424			}
425			/* there is no state on the stack with an error shift ... abort */
426			goto ret1
427
428		case 3: /* no shift yet; clobber input char */
429			if yyDebug >= 2 {
430				__yyfmt__.Printf("error recovery discards %s\n", yyTokname(yytoken))
431			}
432			if yytoken == yyEofCode {
433				goto ret1
434			}
435			yyrcvr.char = -1
436			yytoken = -1
437			goto yynewstate /* try again in the same state */
438		}
439	}
440
441	/* reduction by production yyn */
442	if yyDebug >= 2 {
443		__yyfmt__.Printf("reduce %v in:\n\t%v\n", yyn, yyStatname(yystate))
444	}
445
446	yynt := yyn
447	yypt := yyp
448	_ = yypt // guard against "declared and not used"
449
450	yyp -= yyR2[yyn]
451	// yyp is now the index of $0. Perform the default action. Iff the
452	// reduced production is ε, $1 is possibly out of range.
453	if yyp+1 >= len(yyS) {
454		nyys := make([]yySymType, len(yyS)*2)
455		copy(nyys, yyS)
456		yyS = nyys
457	}
458	yyVAL = yyS[yyp+1]
459
460	/* consult goto table to find next state */
461	yyn = yyR1[yyn]
462	yyg := yyPgo[yyn]
463	yyj := yyg + yyS[yyp].yys + 1
464
465	if yyj >= yyLast {
466		yystate = yyAct[yyg]
467	} else {
468		yystate = yyAct[yyj]
469		if yyChk[yystate] != -yyn {
470			yystate = yyAct[yyg]
471		}
472	}
473	// dummy call; replaced with literal code
474	switch yynt {
475
476	case 1:
477		yyDollar = yyS[yypt-1 : yypt+1]
478		//line query_string.y:40
479		{
480			logDebugGrammar("INPUT")
481		}
482	case 2:
483		yyDollar = yyS[yypt-2 : yypt+1]
484		//line query_string.y:45
485		{
486			logDebugGrammar("SEARCH PARTS")
487		}
488	case 3:
489		yyDollar = yyS[yypt-1 : yypt+1]
490		//line query_string.y:49
491		{
492			logDebugGrammar("SEARCH PART")
493		}
494	case 4:
495		yyDollar = yyS[yypt-3 : yypt+1]
496		//line query_string.y:54
497		{
498			query := yyDollar[2].q
499			if yyDollar[3].pf != nil {
500				if query, ok := query.(BoostableQuery); ok {
501					query.SetBoost(*yyDollar[3].pf)
502				}
503			}
504			switch yyDollar[1].n {
505			case queryShould:
506				yylex.(*lexerWrapper).query.AddShould(query)
507			case queryMust:
508				yylex.(*lexerWrapper).query.AddMust(query)
509			case queryMustNot:
510				yylex.(*lexerWrapper).query.AddMustNot(query)
511			}
512		}
513	case 5:
514		yyDollar = yyS[yypt-0 : yypt+1]
515		//line query_string.y:73
516		{
517			yyVAL.n = queryShould
518		}
519	case 6:
520		yyDollar = yyS[yypt-1 : yypt+1]
521		//line query_string.y:77
522		{
523			logDebugGrammar("PLUS")
524			yyVAL.n = queryMust
525		}
526	case 7:
527		yyDollar = yyS[yypt-1 : yypt+1]
528		//line query_string.y:82
529		{
530			logDebugGrammar("MINUS")
531			yyVAL.n = queryMustNot
532		}
533	case 8:
534		yyDollar = yyS[yypt-1 : yypt+1]
535		//line query_string.y:88
536		{
537			str := yyDollar[1].s
538			logDebugGrammar("STRING - %s", str)
539			var q FieldableQuery
540			if strings.HasPrefix(str, "/") && strings.HasSuffix(str, "/") {
541				q = NewRegexpQuery(str[1 : len(str)-1])
542			} else if strings.ContainsAny(str, "*?") {
543				q = NewWildcardQuery(str)
544			} else {
545				q = NewMatchQuery(str)
546			}
547			yyVAL.q = q
548		}
549	case 9:
550		yyDollar = yyS[yypt-2 : yypt+1]
551		//line query_string.y:102
552		{
553			str := yyDollar[1].s
554			fuzziness, err := strconv.ParseFloat(yyDollar[2].s, 64)
555			if err != nil {
556				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid fuzziness value: %v", err))
557			}
558			logDebugGrammar("FUZZY STRING - %s %f", str, fuzziness)
559			q := NewMatchQuery(str)
560			q.SetFuzziness(int(fuzziness))
561			yyVAL.q = q
562		}
563	case 10:
564		yyDollar = yyS[yypt-4 : yypt+1]
565		//line query_string.y:114
566		{
567			field := yyDollar[1].s
568			str := yyDollar[3].s
569			fuzziness, err := strconv.ParseFloat(yyDollar[4].s, 64)
570			if err != nil {
571				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid fuzziness value: %v", err))
572			}
573			logDebugGrammar("FIELD - %s FUZZY STRING - %s %f", field, str, fuzziness)
574			q := NewMatchQuery(str)
575			q.SetFuzziness(int(fuzziness))
576			q.SetField(field)
577			yyVAL.q = q
578		}
579	case 11:
580		yyDollar = yyS[yypt-1 : yypt+1]
581		//line query_string.y:128
582		{
583			str := yyDollar[1].s
584			logDebugGrammar("STRING - %s", str)
585			q1 := NewMatchQuery(str)
586			val, err := strconv.ParseFloat(yyDollar[1].s, 64)
587			if err != nil {
588				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
589			}
590			inclusive := true
591			q2 := NewNumericRangeInclusiveQuery(&val, &val, &inclusive, &inclusive)
592			q := NewDisjunctionQuery([]Query{q1, q2})
593			q.queryStringMode = true
594			yyVAL.q = q
595		}
596	case 12:
597		yyDollar = yyS[yypt-1 : yypt+1]
598		//line query_string.y:143
599		{
600			phrase := yyDollar[1].s
601			logDebugGrammar("PHRASE - %s", phrase)
602			q := NewMatchPhraseQuery(phrase)
603			yyVAL.q = q
604		}
605	case 13:
606		yyDollar = yyS[yypt-3 : yypt+1]
607		//line query_string.y:150
608		{
609			field := yyDollar[1].s
610			str := yyDollar[3].s
611			logDebugGrammar("FIELD - %s STRING - %s", field, str)
612			var q FieldableQuery
613			if strings.HasPrefix(str, "/") && strings.HasSuffix(str, "/") {
614				q = NewRegexpQuery(str[1 : len(str)-1])
615			} else if strings.ContainsAny(str, "*?") {
616				q = NewWildcardQuery(str)
617			} else {
618				q = NewMatchQuery(str)
619			}
620			q.SetField(field)
621			yyVAL.q = q
622		}
623	case 14:
624		yyDollar = yyS[yypt-3 : yypt+1]
625		//line query_string.y:166
626		{
627			field := yyDollar[1].s
628			str := yyDollar[3].s
629			logDebugGrammar("FIELD - %s STRING - %s", field, str)
630			q1 := NewMatchQuery(str)
631			q1.SetField(field)
632			val, err := strconv.ParseFloat(yyDollar[3].s, 64)
633			if err != nil {
634				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
635			}
636			inclusive := true
637			q2 := NewNumericRangeInclusiveQuery(&val, &val, &inclusive, &inclusive)
638			q2.SetField(field)
639			q := NewDisjunctionQuery([]Query{q1, q2})
640			q.queryStringMode = true
641			yyVAL.q = q
642		}
643	case 15:
644		yyDollar = yyS[yypt-3 : yypt+1]
645		//line query_string.y:184
646		{
647			field := yyDollar[1].s
648			phrase := yyDollar[3].s
649			logDebugGrammar("FIELD - %s PHRASE - %s", field, phrase)
650			q := NewMatchPhraseQuery(phrase)
651			q.SetField(field)
652			yyVAL.q = q
653		}
654	case 16:
655		yyDollar = yyS[yypt-4 : yypt+1]
656		//line query_string.y:193
657		{
658			field := yyDollar[1].s
659			min, err := strconv.ParseFloat(yyDollar[4].s, 64)
660			if err != nil {
661				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
662			}
663			minInclusive := false
664			logDebugGrammar("FIELD - GREATER THAN %f", min)
665			q := NewNumericRangeInclusiveQuery(&min, nil, &minInclusive, nil)
666			q.SetField(field)
667			yyVAL.q = q
668		}
669	case 17:
670		yyDollar = yyS[yypt-5 : yypt+1]
671		//line query_string.y:206
672		{
673			field := yyDollar[1].s
674			min, err := strconv.ParseFloat(yyDollar[5].s, 64)
675			if err != nil {
676				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
677			}
678			minInclusive := true
679			logDebugGrammar("FIELD - GREATER THAN OR EQUAL %f", min)
680			q := NewNumericRangeInclusiveQuery(&min, nil, &minInclusive, nil)
681			q.SetField(field)
682			yyVAL.q = q
683		}
684	case 18:
685		yyDollar = yyS[yypt-4 : yypt+1]
686		//line query_string.y:219
687		{
688			field := yyDollar[1].s
689			max, err := strconv.ParseFloat(yyDollar[4].s, 64)
690			if err != nil {
691				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
692			}
693			maxInclusive := false
694			logDebugGrammar("FIELD - LESS THAN %f", max)
695			q := NewNumericRangeInclusiveQuery(nil, &max, nil, &maxInclusive)
696			q.SetField(field)
697			yyVAL.q = q
698		}
699	case 19:
700		yyDollar = yyS[yypt-5 : yypt+1]
701		//line query_string.y:232
702		{
703			field := yyDollar[1].s
704			max, err := strconv.ParseFloat(yyDollar[5].s, 64)
705			if err != nil {
706				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
707			}
708			maxInclusive := true
709			logDebugGrammar("FIELD - LESS THAN OR EQUAL %f", max)
710			q := NewNumericRangeInclusiveQuery(nil, &max, nil, &maxInclusive)
711			q.SetField(field)
712			yyVAL.q = q
713		}
714	case 20:
715		yyDollar = yyS[yypt-4 : yypt+1]
716		//line query_string.y:245
717		{
718			field := yyDollar[1].s
719			minInclusive := false
720			phrase := yyDollar[4].s
721
722			logDebugGrammar("FIELD - GREATER THAN DATE %s", phrase)
723			minTime, err := queryTimeFromString(phrase)
724			if err != nil {
725				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
726			}
727			q := NewDateRangeInclusiveQuery(minTime, time.Time{}, &minInclusive, nil)
728			q.SetField(field)
729			yyVAL.q = q
730		}
731	case 21:
732		yyDollar = yyS[yypt-5 : yypt+1]
733		//line query_string.y:260
734		{
735			field := yyDollar[1].s
736			minInclusive := true
737			phrase := yyDollar[5].s
738
739			logDebugGrammar("FIELD - GREATER THAN OR EQUAL DATE %s", phrase)
740			minTime, err := queryTimeFromString(phrase)
741			if err != nil {
742				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
743			}
744			q := NewDateRangeInclusiveQuery(minTime, time.Time{}, &minInclusive, nil)
745			q.SetField(field)
746			yyVAL.q = q
747		}
748	case 22:
749		yyDollar = yyS[yypt-4 : yypt+1]
750		//line query_string.y:275
751		{
752			field := yyDollar[1].s
753			maxInclusive := false
754			phrase := yyDollar[4].s
755
756			logDebugGrammar("FIELD - LESS THAN DATE %s", phrase)
757			maxTime, err := queryTimeFromString(phrase)
758			if err != nil {
759				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
760			}
761			q := NewDateRangeInclusiveQuery(time.Time{}, maxTime, nil, &maxInclusive)
762			q.SetField(field)
763			yyVAL.q = q
764		}
765	case 23:
766		yyDollar = yyS[yypt-5 : yypt+1]
767		//line query_string.y:290
768		{
769			field := yyDollar[1].s
770			maxInclusive := true
771			phrase := yyDollar[5].s
772
773			logDebugGrammar("FIELD - LESS THAN OR EQUAL DATE %s", phrase)
774			maxTime, err := queryTimeFromString(phrase)
775			if err != nil {
776				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
777			}
778			q := NewDateRangeInclusiveQuery(time.Time{}, maxTime, nil, &maxInclusive)
779			q.SetField(field)
780			yyVAL.q = q
781		}
782	case 24:
783		yyDollar = yyS[yypt-0 : yypt+1]
784		//line query_string.y:306
785		{
786			yyVAL.pf = nil
787		}
788	case 25:
789		yyDollar = yyS[yypt-1 : yypt+1]
790		//line query_string.y:310
791		{
792			yyVAL.pf = nil
793			boost, err := strconv.ParseFloat(yyDollar[1].s, 64)
794			if err != nil {
795				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid boost value: %v", err))
796			} else {
797				yyVAL.pf = &boost
798			}
799			logDebugGrammar("BOOST %f", boost)
800		}
801	case 26:
802		yyDollar = yyS[yypt-1 : yypt+1]
803		//line query_string.y:322
804		{
805			yyVAL.s = yyDollar[1].s
806		}
807	case 27:
808		yyDollar = yyS[yypt-2 : yypt+1]
809		//line query_string.y:326
810		{
811			yyVAL.s = "-" + yyDollar[2].s
812		}
813	}
814	goto yystack /* stack new state and value */
815}
816