From e84d2d2a59cbf394d282f825a4ffa9f5ed56ab2f Mon Sep 17 00:00:00 2001
From: Seebs <seebs@seebs.net>
Date: Thu, 8 Oct 2020 15:31:21 -0500
Subject: [PATCH] refactor number parsing a bit

There are subtle inconsistencies, like "01" being a valid decimal but not
a valid integer, which vaguely bug me. Cleaning this up, and the corresponding
parser logic.

A number can't have leading spaces because the grammar doesn't
put spaces in them in the first place, so stop accepting them in the
number syntax. This should never have any impact on anything,
it's just simpler.

Update a couple of test cases to reflect this -- no longer testing
that trailing spaces are okay, now testing that they're not, for
instance.
---
 pql/decimal.go      |   39 +-
 pql/decimal_test.go |   20 +-
 pql/pql.peg         |   20 +-
 pql/pql.peg.go      | 1770 ++++++++++++++++++++-----------------------
 4 files changed, 870 insertions(+), 979 deletions(-)

diff --git a/pql/decimal.go b/pql/decimal.go
index 46ef82eb7..61843f580 100644
--- a/pql/decimal.go
+++ b/pql/decimal.go
@@ -309,7 +309,6 @@ func ParseDecimal(s string) (Decimal, error) {
 	var err error
 
 	// General steps:
-	// - Trim leading whitespace/zeros
 	// - Get the sign value
 	// - Trim leading zeros
 	// - Push characters into a buffer
@@ -328,26 +327,23 @@ func ParseDecimal(s string) (Decimal, error) {
 		switch state {
 		case stateSign:
 			switch s[i] {
-			case ' ':
-				continue
 			case '-':
 				sign = true
 				fallthrough
 			case '+':
 				state = stateLeadingZeros
-			default:
-				state = stateLeadingZeros
-				i--
+				// Resume loop and look at next character
+				continue
 			}
+			state = stateLeadingZeros
+			fallthrough
 		case stateLeadingZeros:
-			switch s[i] {
-			case '0':
+			if s[i] == '0' {
 				foundLeadingZero = true
 				continue
-			default:
-				state = stateMantissa
-				i--
 			}
+			state = stateMantissa
+			fallthrough
 		case stateMantissa:
 			switch s[i] {
 			case '.':
@@ -371,23 +367,14 @@ func ParseDecimal(s string) (Decimal, error) {
 		return Decimal{}, errors.New("decimal string is empty")
 	}
 
-	// Trim trailing zeros/spaces of mantissa
-	// for any portion that would have been to the
-	// right of the decimal.
+	// Trim trailing zeros from mantissa. If we ended up with no
+	// characters at all in string, thus, pos == 0, the loop doesn't
+	// happen and we pick [:0], which is correct, probably.
 	trimZeroCnt := 0
-	trimSpaceCnt := 0
-	for i := len(mantissa) - 1; i >= 0; i-- {
-		switch mantissa[i] {
-		case uint8(0), uint8(32): // nil/space
-			trimSpaceCnt++
-			continue
-		case uint8(48): // zero
-			trimZeroCnt++
-			continue
-		}
-		break
+	for i := pos - 1; i >= 0 && mantissa[i] == '0'; i-- {
+		trimZeroCnt++
 	}
-	mantissa = mantissa[:len(mantissa)-trimSpaceCnt-trimZeroCnt]
+	mantissa = mantissa[:pos-trimZeroCnt]
 
 	// Based on where (or if) the decimal was found,
 	// calculate scale.
diff --git a/pql/decimal_test.go b/pql/decimal_test.go
index b5b77fc79..34372651f 100644
--- a/pql/decimal_test.go
+++ b/pql/decimal_test.go
@@ -34,10 +34,9 @@ func TestDecimal(t *testing.T) {
 			{"0", pql.Decimal{0, 0}, ""},
 			{"-0", pql.Decimal{0, 0}, ""},
 			{"0.0", pql.Decimal{0, 0}, ""},
+			{"0.", pql.Decimal{0, 0}, ""},
 			{"-0.00", pql.Decimal{0, 0}, ""},
 			{"123.4567", pql.Decimal{1234567, 4}, ""},
-			{"  123.4567", pql.Decimal{1234567, 4}, ""},
-			{"  123.4567  ", pql.Decimal{1234567, 4}, ""},
 			{"123.456700", pql.Decimal{1234567, 4}, ""},
 			{"00123.4567", pql.Decimal{1234567, 4}, ""},
 			{"+123.4567", pql.Decimal{1234567, 4}, ""},
@@ -56,8 +55,7 @@ func TestDecimal(t *testing.T) {
 			{".123", pql.Decimal{123, 3}, ""},
 			{"0.123", pql.Decimal{123, 3}, ""},
 			{"0.001230", pql.Decimal{123, 5}, ""},
-			{" 0.001230 ", pql.Decimal{123, 5}, ""},
-			{"-0.001230 ", pql.Decimal{-123, 5}, ""},
+			{"-0.001230", pql.Decimal{-123, 5}, ""},
 
 			// int64 edges.
 			{".000009223372036854775807", pql.Decimal{9223372036854775807, 24}, ""},
@@ -83,6 +81,10 @@ func TestDecimal(t *testing.T) {
 			{"abc", pql.Decimal{}, "invalid syntax"},
 			{"0.12.3", pql.Decimal{}, "invalid decimal string"},
 			{"--12300", pql.Decimal{}, "invalid syntax"},
+			{"  123.4567  ", pql.Decimal{}, "invalid syntax"},
+			{"  123.4567", pql.Decimal{}, "invalid syntax"},
+			{"123.4567 ", pql.Decimal{}, "invalid syntax"},
+			{"0.a", pql.Decimal{}, "invalid syntax"},
 
 			// These are no longer error cases since we introduced precision adjustment.
 			//{"922337203685477580.9", pql.Decimal{}, "value out of range"},
@@ -94,12 +96,12 @@ func TestDecimal(t *testing.T) {
 			dec, err := pql.ParseDecimal(test.s)
 			if test.expErr != "" {
 				if err == nil || !strings.Contains(err.Error(), test.expErr) {
-					t.Fatalf("test %d expected error to contain: %s, but got: %v", i, test.expErr, err)
+					t.Fatalf("test %d parsing string `%s`: expected error to contain: %s, but got: %v", i, test.s, test.expErr, err)
 				}
 			} else if err != nil {
 				t.Fatalf("test %d parsing string `%s`: %s", i, test.s, err)
 			} else if dec != test.exp {
-				t.Fatalf("test %d expected: %v, but got: %v", i, test.exp, dec)
+				t.Fatalf("test %d parsing string `%s`: expected: %v, but got: %v", i, test.s, test.exp, dec)
 			}
 		}
 	})
@@ -141,8 +143,6 @@ func TestDecimal(t *testing.T) {
 			exp string
 		}{
 			{"123.4567", "123.4567"},
-			{"  123.4567", "123.4567"},
-			{"  123.4567  ", "123.4567"},
 			{"123.456700", "123.4567"},
 			{"00123.4567", "123.4567"},
 			{"+123.4567", "123.4567"},
@@ -161,8 +161,8 @@ func TestDecimal(t *testing.T) {
 
 			{"0.123", "0.123"},
 			{"0.001230", "0.00123"},
-			{" 0.001230 ", "0.00123"},
-			{"-0.001230 ", "-0.00123"},
+			{"+0.001230", "0.00123"},
+			{"-0.001230", "-0.00123"},
 		}
 		for i, test := range tests {
 			dec, err := pql.ParseDecimal(test.s)
diff --git a/pql/pql.peg b/pql/pql.peg
index 1554f4c26..e413769e1 100644
--- a/pql/pql.peg
+++ b/pql/pql.peg
@@ -4,6 +4,7 @@ type PQL Peg {
      Query
 }
 
+# All input queries consist of a sequence of calls, at the top level.
 Calls <- sp (Call sp)* !.
 Call <-  "Set" {p.startCall("Set")} open col comma args (comma timestamp)? close {p.endCall()}
        / "SetRowAttrs" {p.startCall("SetRowAttrs")} open posfield comma row comma args close {p.endCall()}
@@ -29,19 +30,18 @@ COND <-   '><' { p.addBTWN() }
         / '>' { p.addGT() }
 
 conditional <- {p.startConditional()} condint condLT condfield condLT condint {p.endConditional()}
-condint <- < '-'? [0-9]* '.' [0-9]+ / '0' / '-'? [1-9] [0-9]* > sp {p.condAdd(text)}
+condint <- < decimal > sp {p.condAdd(text)}
 condLT <- <('<=' / '<')> sp {p.condAdd(text)}
 condfield <- <fieldExpr> sp {p.condAdd(text)}
 
 value <-    item
-          / lbrack { p.startList() } list rbrack { p.endList() }
-list <- item (comma list)?
+          / lbrack { p.startList() } items rbrack { p.endList() }
+items <- item (comma items)?
 item <-   'null' &(comma / close) { p.addVal(nil) }
          / 'true' &(comma / close) { p.addVal(true) }
          / 'false' &(comma / close) { p.addVal(false) }
          / timestampfmt { p.addVal(text) }
-         / < '-'? [0-9]+ ('.'[0-9]*)? > { p.addNumVal(text) }
-         / < '-'? '.'[0-9]+ > { p.addNumVal(text) }
+         / < decimal > { p.addNumVal(text) }
          / < IDENT > { p.startCall(text) } open allargs comma? close { p.addVal(p.endCall()) }
          / < ([[A-Z]] / [0-9] / '-' / '_' / ':')+ > { p.addVal(text) }
          / < '"'  doublequotedstring '"' > { p.addVal(text) }
@@ -54,11 +54,10 @@ fieldExpr <- ( [[A-Z]] / '_' ) ( [[A-Z]] / [0-9] / '_' / '-' )*
 field <- <fieldExpr / reserved> { p.addField(text) }
 reserved <- '_row' / '_col' / '_start' / '_end' / '_timestamp' / '_field'
 posfield <- <fieldExpr> { p.addPosStr("_field", text) }
-uint <- [1-9] [0-9]* / '0'
-col <-   <uint> {p.addPosNum("_col", text)}
+col <-   < digits > {p.addPosNum("_col", text)}
         / < '\'' singlequotedstring '\'' > {p.addPosStr("_col", text)}
         / < '"' doublequotedstring '"' > {p.addPosStr("_col", text)}
-row <-   <uint> {p.addPosNum("_row", text)}
+row <-   < digits > {p.addPosNum("_row", text)}
         / < '\'' singlequotedstring '\'' > {p.addPosStr("_row", text)}
         / < '"' doublequotedstring '"' > {p.addPosStr("_row", text)}
 
@@ -70,7 +69,10 @@ comma <- sp ',' sp
 lbrack <- '[' sp
 rbrack <- sp ']' sp
 IDENT <- [[A-Z]] ([[A-Z]] / [0-9])*
-
+digits <- [0-9]+
+signedDigits <- '-'? digits
+decimal <- signedDigits ('.' digits?)?
+         / '-'? '.' digits
 
 timestampbasicfmt <- [0-9][0-9][0-9][0-9]'-'[01][0-9]'-'[0-3][0-9]'T'[0-9][0-9]':'[0-9][0-9]
 timestampfmt <- '"' <timestampbasicfmt> '"' / '\'' <timestampbasicfmt> '\'' / <timestampbasicfmt>
diff --git a/pql/pql.peg.go b/pql/pql.peg.go
index d36ee4bcb..61f765211 100644
--- a/pql/pql.peg.go
+++ b/pql/pql.peg.go
@@ -29,7 +29,7 @@ const (
 	rulecondLT
 	rulecondfield
 	rulevalue
-	rulelist
+	ruleitems
 	ruleitem
 	ruledoublequotedstring
 	rulesinglequotedstring
@@ -37,7 +37,6 @@ const (
 	rulefield
 	rulereserved
 	ruleposfield
-	ruleuint
 	rulecol
 	rulerow
 	ruleopen
@@ -48,6 +47,9 @@ const (
 	rulelbrack
 	rulerbrack
 	ruleIDENT
+	ruledigits
+	rulesignedDigits
+	ruledecimal
 	ruletimestampbasicfmt
 	ruletimestampfmt
 	ruletimestamp
@@ -109,7 +111,6 @@ const (
 	ruleAction54
 	ruleAction55
 	ruleAction56
-	ruleAction57
 )
 
 var rul3s = [...]string{
@@ -125,7 +126,7 @@ var rul3s = [...]string{
 	"condLT",
 	"condfield",
 	"value",
-	"list",
+	"items",
 	"item",
 	"doublequotedstring",
 	"singlequotedstring",
@@ -133,7 +134,6 @@ var rul3s = [...]string{
 	"field",
 	"reserved",
 	"posfield",
-	"uint",
 	"col",
 	"row",
 	"open",
@@ -144,6 +144,9 @@ var rul3s = [...]string{
 	"lbrack",
 	"rbrack",
 	"IDENT",
+	"digits",
+	"signedDigits",
+	"decimal",
 	"timestampbasicfmt",
 	"timestampfmt",
 	"timestamp",
@@ -205,7 +208,6 @@ var rul3s = [...]string{
 	"Action54",
 	"Action55",
 	"Action56",
-	"Action57",
 }
 
 type token32 struct {
@@ -322,7 +324,7 @@ type PQL struct {
 
 	Buffer string
 	buffer []rune
-	rules  [93]func() bool
+	rules  [94]func() bool
 	parse  func(rule ...int) error
 	reset  func()
 	Pretty bool
@@ -511,34 +513,32 @@ func (p *PQL) Execute() {
 		case ruleAction42:
 			p.addNumVal(text)
 		case ruleAction43:
-			p.addNumVal(text)
-		case ruleAction44:
 			p.startCall(text)
-		case ruleAction45:
+		case ruleAction44:
 			p.addVal(p.endCall())
+		case ruleAction45:
+			p.addVal(text)
 		case ruleAction46:
 			p.addVal(text)
 		case ruleAction47:
 			p.addVal(text)
 		case ruleAction48:
-			p.addVal(text)
-		case ruleAction49:
 			p.addField(text)
-		case ruleAction50:
+		case ruleAction49:
 			p.addPosStr("_field", text)
-		case ruleAction51:
+		case ruleAction50:
 			p.addPosNum("_col", text)
+		case ruleAction51:
+			p.addPosStr("_col", text)
 		case ruleAction52:
 			p.addPosStr("_col", text)
 		case ruleAction53:
-			p.addPosStr("_col", text)
-		case ruleAction54:
 			p.addPosNum("_row", text)
+		case ruleAction54:
+			p.addPosStr("_row", text)
 		case ruleAction55:
 			p.addPosStr("_row", text)
 		case ruleAction56:
-			p.addPosStr("_row", text)
-		case ruleAction57:
 			p.addPosStr("_timestamp", text)
 
 		}
@@ -752,7 +752,7 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 								add(rulePegText, position19)
 							}
 							{
-								add(ruleAction57, position)
+								add(ruleAction56, position)
 							}
 							add(ruletimestamp, position18)
 						}
@@ -953,13 +953,13 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 							position47, tokenIndex47 := position, tokenIndex
 							{
 								position49 := position
-								if !_rules[ruleuint]() {
+								if !_rules[ruledigits]() {
 									goto l48
 								}
 								add(rulePegText, position49)
 							}
 							{
-								add(ruleAction54, position)
+								add(ruleAction53, position)
 							}
 							goto l47
 						l48:
@@ -980,7 +980,7 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 								add(rulePegText, position52)
 							}
 							{
-								add(ruleAction55, position)
+								add(ruleAction54, position)
 							}
 							goto l47
 						l51:
@@ -1001,7 +1001,7 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 								add(rulePegText, position54)
 							}
 							{
-								add(ruleAction56, position)
+								add(ruleAction55, position)
 							}
 						}
 					l47:
@@ -2256,94 +2256,16 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 		nil,
 		/* 6 conditional <- <(Action31 condint condLT condfield condLT condint Action32)> */
 		nil,
-		/* 7 condint <- <(<(('-'? [0-9]* '.' [0-9]+) / '0' / ('-'? [1-9] [0-9]*))> sp Action33)> */
+		/* 7 condint <- <(<decimal> sp Action33)> */
 		func() bool {
 			position226, tokenIndex226 := position, tokenIndex
 			{
 				position227 := position
 				{
 					position228 := position
-					{
-						position229, tokenIndex229 := position, tokenIndex
-						{
-							position231, tokenIndex231 := position, tokenIndex
-							if buffer[position] != rune('-') {
-								goto l231
-							}
-							position++
-							goto l232
-						l231:
-							position, tokenIndex = position231, tokenIndex231
-						}
-					l232:
-					l233:
-						{
-							position234, tokenIndex234 := position, tokenIndex
-							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l234
-							}
-							position++
-							goto l233
-						l234:
-							position, tokenIndex = position234, tokenIndex234
-						}
-						if buffer[position] != rune('.') {
-							goto l230
-						}
-						position++
-						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l230
-						}
-						position++
-					l235:
-						{
-							position236, tokenIndex236 := position, tokenIndex
-							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l236
-							}
-							position++
-							goto l235
-						l236:
-							position, tokenIndex = position236, tokenIndex236
-						}
-						goto l229
-					l230:
-						position, tokenIndex = position229, tokenIndex229
-						if buffer[position] != rune('0') {
-							goto l237
-						}
-						position++
-						goto l229
-					l237:
-						position, tokenIndex = position229, tokenIndex229
-						{
-							position238, tokenIndex238 := position, tokenIndex
-							if buffer[position] != rune('-') {
-								goto l238
-							}
-							position++
-							goto l239
-						l238:
-							position, tokenIndex = position238, tokenIndex238
-						}
-					l239:
-						if c := buffer[position]; c < rune('1') || c > rune('9') {
-							goto l226
-						}
-						position++
-					l240:
-						{
-							position241, tokenIndex241 := position, tokenIndex
-							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l241
-							}
-							position++
-							goto l240
-						l241:
-							position, tokenIndex = position241, tokenIndex241
-						}
+					if !_rules[ruledecimal]() {
+						goto l226
 					}
-				l229:
 					add(rulePegText, position228)
 				}
 				if !_rules[rulesp]() {
@@ -2361,1569 +2283,1549 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 		},
 		/* 8 condLT <- <(<(('<' '=') / '<')> sp Action34)> */
 		func() bool {
-			position243, tokenIndex243 := position, tokenIndex
+			position230, tokenIndex230 := position, tokenIndex
 			{
-				position244 := position
+				position231 := position
 				{
-					position245 := position
+					position232 := position
 					{
-						position246, tokenIndex246 := position, tokenIndex
+						position233, tokenIndex233 := position, tokenIndex
 						if buffer[position] != rune('<') {
-							goto l247
+							goto l234
 						}
 						position++
 						if buffer[position] != rune('=') {
-							goto l247
+							goto l234
 						}
 						position++
-						goto l246
-					l247:
-						position, tokenIndex = position246, tokenIndex246
+						goto l233
+					l234:
+						position, tokenIndex = position233, tokenIndex233
 						if buffer[position] != rune('<') {
-							goto l243
+							goto l230
 						}
 						position++
 					}
-				l246:
-					add(rulePegText, position245)
+				l233:
+					add(rulePegText, position232)
 				}
 				if !_rules[rulesp]() {
-					goto l243
+					goto l230
 				}
 				{
 					add(ruleAction34, position)
 				}
-				add(rulecondLT, position244)
+				add(rulecondLT, position231)
 			}
 			return true
-		l243:
-			position, tokenIndex = position243, tokenIndex243
+		l230:
+			position, tokenIndex = position230, tokenIndex230
 			return false
 		},
 		/* 9 condfield <- <(<fieldExpr> sp Action35)> */
 		nil,
-		/* 10 value <- <(item / (lbrack Action36 list rbrack Action37))> */
+		/* 10 value <- <(item / (lbrack Action36 items rbrack Action37))> */
 		func() bool {
-			position250, tokenIndex250 := position, tokenIndex
+			position237, tokenIndex237 := position, tokenIndex
 			{
-				position251 := position
+				position238 := position
 				{
-					position252, tokenIndex252 := position, tokenIndex
+					position239, tokenIndex239 := position, tokenIndex
 					if !_rules[ruleitem]() {
-						goto l253
+						goto l240
 					}
-					goto l252
-				l253:
-					position, tokenIndex = position252, tokenIndex252
+					goto l239
+				l240:
+					position, tokenIndex = position239, tokenIndex239
 					{
-						position254 := position
+						position241 := position
 						if buffer[position] != rune('[') {
-							goto l250
+							goto l237
 						}
 						position++
 						if !_rules[rulesp]() {
-							goto l250
+							goto l237
 						}
-						add(rulelbrack, position254)
+						add(rulelbrack, position241)
 					}
 					{
 						add(ruleAction36, position)
 					}
-					if !_rules[rulelist]() {
-						goto l250
+					if !_rules[ruleitems]() {
+						goto l237
 					}
 					{
-						position256 := position
+						position243 := position
 						if !_rules[rulesp]() {
-							goto l250
+							goto l237
 						}
 						if buffer[position] != rune(']') {
-							goto l250
+							goto l237
 						}
 						position++
 						if !_rules[rulesp]() {
-							goto l250
+							goto l237
 						}
-						add(rulerbrack, position256)
+						add(rulerbrack, position243)
 					}
 					{
 						add(ruleAction37, position)
 					}
 				}
-			l252:
-				add(rulevalue, position251)
+			l239:
+				add(rulevalue, position238)
 			}
 			return true
-		l250:
-			position, tokenIndex = position250, tokenIndex250
+		l237:
+			position, tokenIndex = position237, tokenIndex237
 			return false
 		},
-		/* 11 list <- <(item (comma list)?)> */
+		/* 11 items <- <(item (comma items)?)> */
 		func() bool {
-			position258, tokenIndex258 := position, tokenIndex
+			position245, tokenIndex245 := position, tokenIndex
 			{
-				position259 := position
+				position246 := position
 				if !_rules[ruleitem]() {
-					goto l258
+					goto l245
 				}
 				{
-					position260, tokenIndex260 := position, tokenIndex
+					position247, tokenIndex247 := position, tokenIndex
 					if !_rules[rulecomma]() {
-						goto l260
+						goto l247
 					}
-					if !_rules[rulelist]() {
-						goto l260
+					if !_rules[ruleitems]() {
+						goto l247
 					}
-					goto l261
-				l260:
-					position, tokenIndex = position260, tokenIndex260
+					goto l248
+				l247:
+					position, tokenIndex = position247, tokenIndex247
 				}
-			l261:
-				add(rulelist, position259)
+			l248:
+				add(ruleitems, position246)
 			}
 			return true
-		l258:
-			position, tokenIndex = position258, tokenIndex258
+		l245:
+			position, tokenIndex = position245, tokenIndex245
 			return false
 		},
-		/* 12 item <- <(('n' 'u' 'l' 'l' &(comma / close) Action38) / ('t' 'r' 'u' 'e' &(comma / close) Action39) / ('f' 'a' 'l' 's' 'e' &(comma / close) Action40) / (timestampfmt Action41) / (<('-'? [0-9]+ ('.' [0-9]*)?)> Action42) / (<('-'? '.' [0-9]+)> Action43) / (<IDENT> Action44 open allargs comma? close Action45) / (<([a-z] / [A-Z] / [0-9] / '-' / '_' / ':')+> Action46) / (<('"' doublequotedstring '"')> Action47) / (<('\'' singlequotedstring '\'')> Action48))> */
+		/* 12 item <- <(('n' 'u' 'l' 'l' &(comma / close) Action38) / ('t' 'r' 'u' 'e' &(comma / close) Action39) / ('f' 'a' 'l' 's' 'e' &(comma / close) Action40) / (timestampfmt Action41) / (<decimal> Action42) / (<IDENT> Action43 open allargs comma? close Action44) / (<([a-z] / [A-Z] / [0-9] / '-' / '_' / ':')+> Action45) / (<('"' doublequotedstring '"')> Action46) / (<('\'' singlequotedstring '\'')> Action47))> */
 		func() bool {
-			position262, tokenIndex262 := position, tokenIndex
+			position249, tokenIndex249 := position, tokenIndex
 			{
-				position263 := position
+				position250 := position
 				{
-					position264, tokenIndex264 := position, tokenIndex
+					position251, tokenIndex251 := position, tokenIndex
 					if buffer[position] != rune('n') {
-						goto l265
+						goto l252
 					}
 					position++
 					if buffer[position] != rune('u') {
-						goto l265
+						goto l252
 					}
 					position++
 					if buffer[position] != rune('l') {
-						goto l265
+						goto l252
 					}
 					position++
 					if buffer[position] != rune('l') {
-						goto l265
+						goto l252
 					}
 					position++
 					{
-						position266, tokenIndex266 := position, tokenIndex
+						position253, tokenIndex253 := position, tokenIndex
 						{
-							position267, tokenIndex267 := position, tokenIndex
+							position254, tokenIndex254 := position, tokenIndex
 							if !_rules[rulecomma]() {
-								goto l268
+								goto l255
 							}
-							goto l267
-						l268:
-							position, tokenIndex = position267, tokenIndex267
+							goto l254
+						l255:
+							position, tokenIndex = position254, tokenIndex254
 							if !_rules[ruleclose]() {
-								goto l265
+								goto l252
 							}
 						}
-					l267:
-						position, tokenIndex = position266, tokenIndex266
+					l254:
+						position, tokenIndex = position253, tokenIndex253
 					}
 					{
 						add(ruleAction38, position)
 					}
-					goto l264
-				l265:
-					position, tokenIndex = position264, tokenIndex264
+					goto l251
+				l252:
+					position, tokenIndex = position251, tokenIndex251
 					if buffer[position] != rune('t') {
-						goto l270
+						goto l257
 					}
 					position++
 					if buffer[position] != rune('r') {
-						goto l270
+						goto l257
 					}
 					position++
 					if buffer[position] != rune('u') {
-						goto l270
+						goto l257
 					}
 					position++
 					if buffer[position] != rune('e') {
-						goto l270
+						goto l257
 					}
 					position++
 					{
-						position271, tokenIndex271 := position, tokenIndex
+						position258, tokenIndex258 := position, tokenIndex
 						{
-							position272, tokenIndex272 := position, tokenIndex
+							position259, tokenIndex259 := position, tokenIndex
 							if !_rules[rulecomma]() {
-								goto l273
+								goto l260
 							}
-							goto l272
-						l273:
-							position, tokenIndex = position272, tokenIndex272
+							goto l259
+						l260:
+							position, tokenIndex = position259, tokenIndex259
 							if !_rules[ruleclose]() {
-								goto l270
+								goto l257
 							}
 						}
-					l272:
-						position, tokenIndex = position271, tokenIndex271
+					l259:
+						position, tokenIndex = position258, tokenIndex258
 					}
 					{
 						add(ruleAction39, position)
 					}
-					goto l264
-				l270:
-					position, tokenIndex = position264, tokenIndex264
+					goto l251
+				l257:
+					position, tokenIndex = position251, tokenIndex251
 					if buffer[position] != rune('f') {
-						goto l275
+						goto l262
 					}
 					position++
 					if buffer[position] != rune('a') {
-						goto l275
+						goto l262
 					}
 					position++
 					if buffer[position] != rune('l') {
-						goto l275
+						goto l262
 					}
 					position++
 					if buffer[position] != rune('s') {
-						goto l275
+						goto l262
 					}
 					position++
 					if buffer[position] != rune('e') {
-						goto l275
+						goto l262
 					}
 					position++
 					{
-						position276, tokenIndex276 := position, tokenIndex
+						position263, tokenIndex263 := position, tokenIndex
 						{
-							position277, tokenIndex277 := position, tokenIndex
+							position264, tokenIndex264 := position, tokenIndex
 							if !_rules[rulecomma]() {
-								goto l278
+								goto l265
 							}
-							goto l277
-						l278:
-							position, tokenIndex = position277, tokenIndex277
+							goto l264
+						l265:
+							position, tokenIndex = position264, tokenIndex264
 							if !_rules[ruleclose]() {
-								goto l275
+								goto l262
 							}
 						}
-					l277:
-						position, tokenIndex = position276, tokenIndex276
+					l264:
+						position, tokenIndex = position263, tokenIndex263
 					}
 					{
 						add(ruleAction40, position)
 					}
-					goto l264
-				l275:
-					position, tokenIndex = position264, tokenIndex264
+					goto l251
+				l262:
+					position, tokenIndex = position251, tokenIndex251
 					if !_rules[ruletimestampfmt]() {
-						goto l280
+						goto l267
 					}
 					{
 						add(ruleAction41, position)
 					}
-					goto l264
-				l280:
-					position, tokenIndex = position264, tokenIndex264
+					goto l251
+				l267:
+					position, tokenIndex = position251, tokenIndex251
 					{
-						position283 := position
-						{
-							position284, tokenIndex284 := position, tokenIndex
-							if buffer[position] != rune('-') {
-								goto l284
-							}
-							position++
-							goto l285
-						l284:
-							position, tokenIndex = position284, tokenIndex284
+						position270 := position
+						if !_rules[ruledecimal]() {
+							goto l269
 						}
-					l285:
-						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l282
-						}
-						position++
-					l286:
-						{
-							position287, tokenIndex287 := position, tokenIndex
-							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l287
-							}
-							position++
-							goto l286
-						l287:
-							position, tokenIndex = position287, tokenIndex287
-						}
-						{
-							position288, tokenIndex288 := position, tokenIndex
-							if buffer[position] != rune('.') {
-								goto l288
-							}
-							position++
-						l290:
-							{
-								position291, tokenIndex291 := position, tokenIndex
-								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l291
-								}
-								position++
-								goto l290
-							l291:
-								position, tokenIndex = position291, tokenIndex291
-							}
-							goto l289
-						l288:
-							position, tokenIndex = position288, tokenIndex288
-						}
-					l289:
-						add(rulePegText, position283)
+						add(rulePegText, position270)
 					}
 					{
 						add(ruleAction42, position)
 					}
-					goto l264
-				l282:
-					position, tokenIndex = position264, tokenIndex264
+					goto l251
+				l269:
+					position, tokenIndex = position251, tokenIndex251
 					{
-						position294 := position
-						{
-							position295, tokenIndex295 := position, tokenIndex
-							if buffer[position] != rune('-') {
-								goto l295
-							}
-							position++
-							goto l296
-						l295:
-							position, tokenIndex = position295, tokenIndex295
+						position273 := position
+						if !_rules[ruleIDENT]() {
+							goto l272
 						}
-					l296:
-						if buffer[position] != rune('.') {
-							goto l293
-						}
-						position++
-						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l293
-						}
-						position++
-					l297:
-						{
-							position298, tokenIndex298 := position, tokenIndex
-							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l298
-							}
-							position++
-							goto l297
-						l298:
-							position, tokenIndex = position298, tokenIndex298
-						}
-						add(rulePegText, position294)
+						add(rulePegText, position273)
 					}
 					{
 						add(ruleAction43, position)
 					}
-					goto l264
-				l293:
-					position, tokenIndex = position264, tokenIndex264
+					if !_rules[ruleopen]() {
+						goto l272
+					}
+					if !_rules[ruleallargs]() {
+						goto l272
+					}
 					{
-						position301 := position
-						if !_rules[ruleIDENT]() {
-							goto l300
+						position275, tokenIndex275 := position, tokenIndex
+						if !_rules[rulecomma]() {
+							goto l275
 						}
-						add(rulePegText, position301)
+						goto l276
+					l275:
+						position, tokenIndex = position275, tokenIndex275
+					}
+				l276:
+					if !_rules[ruleclose]() {
+						goto l272
 					}
 					{
 						add(ruleAction44, position)
 					}
-					if !_rules[ruleopen]() {
-						goto l300
-					}
-					if !_rules[ruleallargs]() {
-						goto l300
-					}
+					goto l251
+				l272:
+					position, tokenIndex = position251, tokenIndex251
 					{
-						position303, tokenIndex303 := position, tokenIndex
-						if !_rules[rulecomma]() {
-							goto l303
+						position279 := position
+						{
+							position282, tokenIndex282 := position, tokenIndex
+							if c := buffer[position]; c < rune('a') || c > rune('z') {
+								goto l283
+							}
+							position++
+							goto l282
+						l283:
+							position, tokenIndex = position282, tokenIndex282
+							if c := buffer[position]; c < rune('A') || c > rune('Z') {
+								goto l284
+							}
+							position++
+							goto l282
+						l284:
+							position, tokenIndex = position282, tokenIndex282
+							if c := buffer[position]; c < rune('0') || c > rune('9') {
+								goto l285
+							}
+							position++
+							goto l282
+						l285:
+							position, tokenIndex = position282, tokenIndex282
+							if buffer[position] != rune('-') {
+								goto l286
+							}
+							position++
+							goto l282
+						l286:
+							position, tokenIndex = position282, tokenIndex282
+							if buffer[position] != rune('_') {
+								goto l287
+							}
+							position++
+							goto l282
+						l287:
+							position, tokenIndex = position282, tokenIndex282
+							if buffer[position] != rune(':') {
+								goto l278
+							}
+							position++
 						}
-						goto l304
-					l303:
-						position, tokenIndex = position303, tokenIndex303
-					}
-				l304:
-					if !_rules[ruleclose]() {
-						goto l300
+					l282:
+					l280:
+						{
+							position281, tokenIndex281 := position, tokenIndex
+							{
+								position288, tokenIndex288 := position, tokenIndex
+								if c := buffer[position]; c < rune('a') || c > rune('z') {
+									goto l289
+								}
+								position++
+								goto l288
+							l289:
+								position, tokenIndex = position288, tokenIndex288
+								if c := buffer[position]; c < rune('A') || c > rune('Z') {
+									goto l290
+								}
+								position++
+								goto l288
+							l290:
+								position, tokenIndex = position288, tokenIndex288
+								if c := buffer[position]; c < rune('0') || c > rune('9') {
+									goto l291
+								}
+								position++
+								goto l288
+							l291:
+								position, tokenIndex = position288, tokenIndex288
+								if buffer[position] != rune('-') {
+									goto l292
+								}
+								position++
+								goto l288
+							l292:
+								position, tokenIndex = position288, tokenIndex288
+								if buffer[position] != rune('_') {
+									goto l293
+								}
+								position++
+								goto l288
+							l293:
+								position, tokenIndex = position288, tokenIndex288
+								if buffer[position] != rune(':') {
+									goto l281
+								}
+								position++
+							}
+						l288:
+							goto l280
+						l281:
+							position, tokenIndex = position281, tokenIndex281
+						}
+						add(rulePegText, position279)
 					}
 					{
 						add(ruleAction45, position)
 					}
-					goto l264
-				l300:
-					position, tokenIndex = position264, tokenIndex264
+					goto l251
+				l278:
+					position, tokenIndex = position251, tokenIndex251
 					{
-						position307 := position
-						{
-							position310, tokenIndex310 := position, tokenIndex
-							if c := buffer[position]; c < rune('a') || c > rune('z') {
-								goto l311
-							}
-							position++
-							goto l310
-						l311:
-							position, tokenIndex = position310, tokenIndex310
-							if c := buffer[position]; c < rune('A') || c > rune('Z') {
-								goto l312
-							}
-							position++
-							goto l310
-						l312:
-							position, tokenIndex = position310, tokenIndex310
-							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l313
-							}
-							position++
-							goto l310
-						l313:
-							position, tokenIndex = position310, tokenIndex310
-							if buffer[position] != rune('-') {
-								goto l314
-							}
-							position++
-							goto l310
-						l314:
-							position, tokenIndex = position310, tokenIndex310
-							if buffer[position] != rune('_') {
-								goto l315
-							}
-							position++
-							goto l310
-						l315:
-							position, tokenIndex = position310, tokenIndex310
-							if buffer[position] != rune(':') {
-								goto l306
-							}
-							position++
+						position296 := position
+						if buffer[position] != rune('"') {
+							goto l295
 						}
-					l310:
-					l308:
-						{
-							position309, tokenIndex309 := position, tokenIndex
-							{
-								position316, tokenIndex316 := position, tokenIndex
-								if c := buffer[position]; c < rune('a') || c > rune('z') {
-									goto l317
-								}
-								position++
-								goto l316
-							l317:
-								position, tokenIndex = position316, tokenIndex316
-								if c := buffer[position]; c < rune('A') || c > rune('Z') {
-									goto l318
-								}
-								position++
-								goto l316
-							l318:
-								position, tokenIndex = position316, tokenIndex316
-								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l319
-								}
-								position++
-								goto l316
-							l319:
-								position, tokenIndex = position316, tokenIndex316
-								if buffer[position] != rune('-') {
-									goto l320
-								}
-								position++
-								goto l316
-							l320:
-								position, tokenIndex = position316, tokenIndex316
-								if buffer[position] != rune('_') {
-									goto l321
-								}
-								position++
-								goto l316
-							l321:
-								position, tokenIndex = position316, tokenIndex316
-								if buffer[position] != rune(':') {
-									goto l309
-								}
-								position++
-							}
-						l316:
-							goto l308
-						l309:
-							position, tokenIndex = position309, tokenIndex309
+						position++
+						if !_rules[ruledoublequotedstring]() {
+							goto l295
 						}
-						add(rulePegText, position307)
+						if buffer[position] != rune('"') {
+							goto l295
+						}
+						position++
+						add(rulePegText, position296)
 					}
 					{
 						add(ruleAction46, position)
 					}
-					goto l264
-				l306:
-					position, tokenIndex = position264, tokenIndex264
+					goto l251
+				l295:
+					position, tokenIndex = position251, tokenIndex251
 					{
-						position324 := position
-						if buffer[position] != rune('"') {
-							goto l323
+						position298 := position
+						if buffer[position] != rune('\'') {
+							goto l249
 						}
 						position++
-						if !_rules[ruledoublequotedstring]() {
-							goto l323
+						if !_rules[rulesinglequotedstring]() {
+							goto l249
 						}
-						if buffer[position] != rune('"') {
-							goto l323
+						if buffer[position] != rune('\'') {
+							goto l249
 						}
 						position++
-						add(rulePegText, position324)
+						add(rulePegText, position298)
 					}
 					{
 						add(ruleAction47, position)
 					}
-					goto l264
-				l323:
-					position, tokenIndex = position264, tokenIndex264
-					{
-						position326 := position
-						if buffer[position] != rune('\'') {
-							goto l262
-						}
-						position++
-						if !_rules[rulesinglequotedstring]() {
-							goto l262
-						}
-						if buffer[position] != rune('\'') {
-							goto l262
-						}
-						position++
-						add(rulePegText, position326)
-					}
-					{
-						add(ruleAction48, position)
-					}
 				}
-			l264:
-				add(ruleitem, position263)
+			l251:
+				add(ruleitem, position250)
 			}
 			return true
-		l262:
-			position, tokenIndex = position262, tokenIndex262
+		l249:
+			position, tokenIndex = position249, tokenIndex249
 			return false
 		},
 		/* 13 doublequotedstring <- <(('\\' '"') / ('\\' '\\') / ('\\' 'n') / ('\\' 't') / (!('"' / '\\') .))*> */
 		func() bool {
 			{
-				position329 := position
-			l330:
+				position301 := position
+			l302:
 				{
-					position331, tokenIndex331 := position, tokenIndex
+					position303, tokenIndex303 := position, tokenIndex
 					{
-						position332, tokenIndex332 := position, tokenIndex
+						position304, tokenIndex304 := position, tokenIndex
 						if buffer[position] != rune('\\') {
-							goto l333
+							goto l305
 						}
 						position++
 						if buffer[position] != rune('"') {
-							goto l333
+							goto l305
 						}
 						position++
-						goto l332
-					l333:
-						position, tokenIndex = position332, tokenIndex332
+						goto l304
+					l305:
+						position, tokenIndex = position304, tokenIndex304
 						if buffer[position] != rune('\\') {
-							goto l334
+							goto l306
 						}
 						position++
 						if buffer[position] != rune('\\') {
-							goto l334
+							goto l306
 						}
 						position++
-						goto l332
-					l334:
-						position, tokenIndex = position332, tokenIndex332
+						goto l304
+					l306:
+						position, tokenIndex = position304, tokenIndex304
 						if buffer[position] != rune('\\') {
-							goto l335
+							goto l307
 						}
 						position++
 						if buffer[position] != rune('n') {
-							goto l335
+							goto l307
 						}
 						position++
-						goto l332
-					l335:
-						position, tokenIndex = position332, tokenIndex332
+						goto l304
+					l307:
+						position, tokenIndex = position304, tokenIndex304
 						if buffer[position] != rune('\\') {
-							goto l336
+							goto l308
 						}
 						position++
 						if buffer[position] != rune('t') {
-							goto l336
+							goto l308
 						}
 						position++
-						goto l332
-					l336:
-						position, tokenIndex = position332, tokenIndex332
+						goto l304
+					l308:
+						position, tokenIndex = position304, tokenIndex304
 						{
-							position337, tokenIndex337 := position, tokenIndex
+							position309, tokenIndex309 := position, tokenIndex
 							{
-								position338, tokenIndex338 := position, tokenIndex
+								position310, tokenIndex310 := position, tokenIndex
 								if buffer[position] != rune('"') {
-									goto l339
+									goto l311
 								}
 								position++
-								goto l338
-							l339:
-								position, tokenIndex = position338, tokenIndex338
+								goto l310
+							l311:
+								position, tokenIndex = position310, tokenIndex310
 								if buffer[position] != rune('\\') {
-									goto l337
+									goto l309
 								}
 								position++
 							}
-						l338:
-							goto l331
-						l337:
-							position, tokenIndex = position337, tokenIndex337
+						l310:
+							goto l303
+						l309:
+							position, tokenIndex = position309, tokenIndex309
 						}
 						if !matchDot() {
-							goto l331
+							goto l303
 						}
 					}
-				l332:
-					goto l330
-				l331:
-					position, tokenIndex = position331, tokenIndex331
+				l304:
+					goto l302
+				l303:
+					position, tokenIndex = position303, tokenIndex303
 				}
-				add(ruledoublequotedstring, position329)
+				add(ruledoublequotedstring, position301)
 			}
 			return true
 		},
 		/* 14 singlequotedstring <- <(('\\' '\'') / ('\\' '\\') / ('\\' 'n') / ('\\' 't') / (!('\'' / '\\') .))*> */
 		func() bool {
 			{
-				position341 := position
-			l342:
+				position313 := position
+			l314:
 				{
-					position343, tokenIndex343 := position, tokenIndex
+					position315, tokenIndex315 := position, tokenIndex
 					{
-						position344, tokenIndex344 := position, tokenIndex
+						position316, tokenIndex316 := position, tokenIndex
 						if buffer[position] != rune('\\') {
-							goto l345
+							goto l317
 						}
 						position++
 						if buffer[position] != rune('\'') {
-							goto l345
+							goto l317
 						}
 						position++
-						goto l344
-					l345:
-						position, tokenIndex = position344, tokenIndex344
+						goto l316
+					l317:
+						position, tokenIndex = position316, tokenIndex316
 						if buffer[position] != rune('\\') {
-							goto l346
+							goto l318
 						}
 						position++
 						if buffer[position] != rune('\\') {
-							goto l346
+							goto l318
 						}
 						position++
-						goto l344
-					l346:
-						position, tokenIndex = position344, tokenIndex344
+						goto l316
+					l318:
+						position, tokenIndex = position316, tokenIndex316
 						if buffer[position] != rune('\\') {
-							goto l347
+							goto l319
 						}
 						position++
 						if buffer[position] != rune('n') {
-							goto l347
+							goto l319
 						}
 						position++
-						goto l344
-					l347:
-						position, tokenIndex = position344, tokenIndex344
+						goto l316
+					l319:
+						position, tokenIndex = position316, tokenIndex316
 						if buffer[position] != rune('\\') {
-							goto l348
+							goto l320
 						}
 						position++
 						if buffer[position] != rune('t') {
-							goto l348
+							goto l320
 						}
 						position++
-						goto l344
-					l348:
-						position, tokenIndex = position344, tokenIndex344
+						goto l316
+					l320:
+						position, tokenIndex = position316, tokenIndex316
 						{
-							position349, tokenIndex349 := position, tokenIndex
+							position321, tokenIndex321 := position, tokenIndex
 							{
-								position350, tokenIndex350 := position, tokenIndex
+								position322, tokenIndex322 := position, tokenIndex
 								if buffer[position] != rune('\'') {
-									goto l351
+									goto l323
 								}
 								position++
-								goto l350
-							l351:
-								position, tokenIndex = position350, tokenIndex350
+								goto l322
+							l323:
+								position, tokenIndex = position322, tokenIndex322
 								if buffer[position] != rune('\\') {
-									goto l349
+									goto l321
 								}
 								position++
 							}
-						l350:
-							goto l343
-						l349:
-							position, tokenIndex = position349, tokenIndex349
+						l322:
+							goto l315
+						l321:
+							position, tokenIndex = position321, tokenIndex321
 						}
 						if !matchDot() {
-							goto l343
+							goto l315
 						}
 					}
-				l344:
-					goto l342
-				l343:
-					position, tokenIndex = position343, tokenIndex343
+				l316:
+					goto l314
+				l315:
+					position, tokenIndex = position315, tokenIndex315
 				}
-				add(rulesinglequotedstring, position341)
+				add(rulesinglequotedstring, position313)
 			}
 			return true
 		},
 		/* 15 fieldExpr <- <(([a-z] / [A-Z] / '_') ([a-z] / [A-Z] / [0-9] / '_' / '-')*)> */
 		func() bool {
-			position352, tokenIndex352 := position, tokenIndex
+			position324, tokenIndex324 := position, tokenIndex
 			{
-				position353 := position
+				position325 := position
 				{
-					position354, tokenIndex354 := position, tokenIndex
+					position326, tokenIndex326 := position, tokenIndex
 					if c := buffer[position]; c < rune('a') || c > rune('z') {
-						goto l355
+						goto l327
 					}
 					position++
-					goto l354
-				l355:
-					position, tokenIndex = position354, tokenIndex354
+					goto l326
+				l327:
+					position, tokenIndex = position326, tokenIndex326
 					if c := buffer[position]; c < rune('A') || c > rune('Z') {
-						goto l356
+						goto l328
 					}
 					position++
-					goto l354
-				l356:
-					position, tokenIndex = position354, tokenIndex354
+					goto l326
+				l328:
+					position, tokenIndex = position326, tokenIndex326
 					if buffer[position] != rune('_') {
-						goto l352
+						goto l324
 					}
 					position++
 				}
-			l354:
-			l357:
+			l326:
+			l329:
 				{
-					position358, tokenIndex358 := position, tokenIndex
+					position330, tokenIndex330 := position, tokenIndex
 					{
-						position359, tokenIndex359 := position, tokenIndex
+						position331, tokenIndex331 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l360
+							goto l332
 						}
 						position++
-						goto l359
-					l360:
-						position, tokenIndex = position359, tokenIndex359
+						goto l331
+					l332:
+						position, tokenIndex = position331, tokenIndex331
 						if c := buffer[position]; c < rune('A') || c > rune('Z') {
-							goto l361
+							goto l333
 						}
 						position++
-						goto l359
-					l361:
-						position, tokenIndex = position359, tokenIndex359
+						goto l331
+					l333:
+						position, tokenIndex = position331, tokenIndex331
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l362
+							goto l334
 						}
 						position++
-						goto l359
-					l362:
-						position, tokenIndex = position359, tokenIndex359
+						goto l331
+					l334:
+						position, tokenIndex = position331, tokenIndex331
 						if buffer[position] != rune('_') {
-							goto l363
+							goto l335
 						}
 						position++
-						goto l359
-					l363:
-						position, tokenIndex = position359, tokenIndex359
+						goto l331
+					l335:
+						position, tokenIndex = position331, tokenIndex331
 						if buffer[position] != rune('-') {
-							goto l358
+							goto l330
 						}
 						position++
 					}
-				l359:
-					goto l357
-				l358:
-					position, tokenIndex = position358, tokenIndex358
+				l331:
+					goto l329
+				l330:
+					position, tokenIndex = position330, tokenIndex330
 				}
-				add(rulefieldExpr, position353)
+				add(rulefieldExpr, position325)
 			}
 			return true
-		l352:
-			position, tokenIndex = position352, tokenIndex352
+		l324:
+			position, tokenIndex = position324, tokenIndex324
 			return false
 		},
-		/* 16 field <- <(<(fieldExpr / reserved)> Action49)> */
+		/* 16 field <- <(<(fieldExpr / reserved)> Action48)> */
 		func() bool {
-			position364, tokenIndex364 := position, tokenIndex
+			position336, tokenIndex336 := position, tokenIndex
 			{
-				position365 := position
+				position337 := position
 				{
-					position366 := position
+					position338 := position
 					{
-						position367, tokenIndex367 := position, tokenIndex
+						position339, tokenIndex339 := position, tokenIndex
 						if !_rules[rulefieldExpr]() {
-							goto l368
+							goto l340
 						}
-						goto l367
-					l368:
-						position, tokenIndex = position367, tokenIndex367
+						goto l339
+					l340:
+						position, tokenIndex = position339, tokenIndex339
 						{
-							position369 := position
+							position341 := position
 							{
-								position370, tokenIndex370 := position, tokenIndex
+								position342, tokenIndex342 := position, tokenIndex
 								if buffer[position] != rune('_') {
-									goto l371
+									goto l343
 								}
 								position++
 								if buffer[position] != rune('r') {
-									goto l371
+									goto l343
 								}
 								position++
 								if buffer[position] != rune('o') {
-									goto l371
+									goto l343
 								}
 								position++
 								if buffer[position] != rune('w') {
-									goto l371
+									goto l343
 								}
 								position++
-								goto l370
-							l371:
-								position, tokenIndex = position370, tokenIndex370
+								goto l342
+							l343:
+								position, tokenIndex = position342, tokenIndex342
 								if buffer[position] != rune('_') {
-									goto l372
+									goto l344
 								}
 								position++
 								if buffer[position] != rune('c') {
-									goto l372
+									goto l344
 								}
 								position++
 								if buffer[position] != rune('o') {
-									goto l372
+									goto l344
 								}
 								position++
 								if buffer[position] != rune('l') {
-									goto l372
+									goto l344
 								}
 								position++
-								goto l370
-							l372:
-								position, tokenIndex = position370, tokenIndex370
+								goto l342
+							l344:
+								position, tokenIndex = position342, tokenIndex342
 								if buffer[position] != rune('_') {
-									goto l373
+									goto l345
 								}
 								position++
 								if buffer[position] != rune('s') {
-									goto l373
+									goto l345
 								}
 								position++
 								if buffer[position] != rune('t') {
-									goto l373
+									goto l345
 								}
 								position++
 								if buffer[position] != rune('a') {
-									goto l373
+									goto l345
 								}
 								position++
 								if buffer[position] != rune('r') {
-									goto l373
+									goto l345
 								}
 								position++
 								if buffer[position] != rune('t') {
-									goto l373
+									goto l345
 								}
 								position++
-								goto l370
-							l373:
-								position, tokenIndex = position370, tokenIndex370
+								goto l342
+							l345:
+								position, tokenIndex = position342, tokenIndex342
 								if buffer[position] != rune('_') {
-									goto l374
+									goto l346
 								}
 								position++
 								if buffer[position] != rune('e') {
-									goto l374
+									goto l346
 								}
 								position++
 								if buffer[position] != rune('n') {
-									goto l374
+									goto l346
 								}
 								position++
 								if buffer[position] != rune('d') {
-									goto l374
+									goto l346
 								}
 								position++
-								goto l370
-							l374:
-								position, tokenIndex = position370, tokenIndex370
+								goto l342
+							l346:
+								position, tokenIndex = position342, tokenIndex342
 								if buffer[position] != rune('_') {
-									goto l375
+									goto l347
 								}
 								position++
 								if buffer[position] != rune('t') {
-									goto l375
+									goto l347
 								}
 								position++
 								if buffer[position] != rune('i') {
-									goto l375
+									goto l347
 								}
 								position++
 								if buffer[position] != rune('m') {
-									goto l375
+									goto l347
 								}
 								position++
 								if buffer[position] != rune('e') {
-									goto l375
+									goto l347
 								}
 								position++
 								if buffer[position] != rune('s') {
-									goto l375
+									goto l347
 								}
 								position++
 								if buffer[position] != rune('t') {
-									goto l375
+									goto l347
 								}
 								position++
 								if buffer[position] != rune('a') {
-									goto l375
+									goto l347
 								}
 								position++
 								if buffer[position] != rune('m') {
-									goto l375
+									goto l347
 								}
 								position++
 								if buffer[position] != rune('p') {
-									goto l375
+									goto l347
 								}
 								position++
-								goto l370
-							l375:
-								position, tokenIndex = position370, tokenIndex370
+								goto l342
+							l347:
+								position, tokenIndex = position342, tokenIndex342
 								if buffer[position] != rune('_') {
-									goto l364
+									goto l336
 								}
 								position++
 								if buffer[position] != rune('f') {
-									goto l364
+									goto l336
 								}
 								position++
 								if buffer[position] != rune('i') {
-									goto l364
+									goto l336
 								}
 								position++
 								if buffer[position] != rune('e') {
-									goto l364
+									goto l336
 								}
 								position++
 								if buffer[position] != rune('l') {
-									goto l364
+									goto l336
 								}
 								position++
 								if buffer[position] != rune('d') {
-									goto l364
+									goto l336
 								}
 								position++
 							}
-						l370:
-							add(rulereserved, position369)
+						l342:
+							add(rulereserved, position341)
 						}
 					}
-				l367:
-					add(rulePegText, position366)
+				l339:
+					add(rulePegText, position338)
 				}
 				{
-					add(ruleAction49, position)
+					add(ruleAction48, position)
 				}
-				add(rulefield, position365)
+				add(rulefield, position337)
 			}
 			return true
-		l364:
-			position, tokenIndex = position364, tokenIndex364
+		l336:
+			position, tokenIndex = position336, tokenIndex336
 			return false
 		},
 		/* 17 reserved <- <(('_' 'r' 'o' 'w') / ('_' 'c' 'o' 'l') / ('_' 's' 't' 'a' 'r' 't') / ('_' 'e' 'n' 'd') / ('_' 't' 'i' 'm' 'e' 's' 't' 'a' 'm' 'p') / ('_' 'f' 'i' 'e' 'l' 'd'))> */
 		nil,
-		/* 18 posfield <- <(<fieldExpr> Action50)> */
+		/* 18 posfield <- <(<fieldExpr> Action49)> */
 		func() bool {
-			position378, tokenIndex378 := position, tokenIndex
+			position350, tokenIndex350 := position, tokenIndex
 			{
-				position379 := position
+				position351 := position
 				{
-					position380 := position
+					position352 := position
 					if !_rules[rulefieldExpr]() {
-						goto l378
+						goto l350
 					}
-					add(rulePegText, position380)
+					add(rulePegText, position352)
 				}
 				{
-					add(ruleAction50, position)
+					add(ruleAction49, position)
 				}
-				add(ruleposfield, position379)
+				add(ruleposfield, position351)
 			}
 			return true
-		l378:
-			position, tokenIndex = position378, tokenIndex378
+		l350:
+			position, tokenIndex = position350, tokenIndex350
 			return false
 		},
-		/* 19 uint <- <(([1-9] [0-9]*) / '0')> */
+		/* 19 col <- <((<digits> Action50) / (<('\'' singlequotedstring '\'')> Action51) / (<('"' doublequotedstring '"')> Action52))> */
 		func() bool {
-			position382, tokenIndex382 := position, tokenIndex
+			position354, tokenIndex354 := position, tokenIndex
 			{
-				position383 := position
+				position355 := position
 				{
-					position384, tokenIndex384 := position, tokenIndex
-					if c := buffer[position]; c < rune('1') || c > rune('9') {
-						goto l385
-					}
-					position++
-				l386:
+					position356, tokenIndex356 := position, tokenIndex
 					{
-						position387, tokenIndex387 := position, tokenIndex
-						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l387
+						position358 := position
+						if !_rules[ruledigits]() {
+							goto l357
+						}
+						add(rulePegText, position358)
+					}
+					{
+						add(ruleAction50, position)
+					}
+					goto l356
+				l357:
+					position, tokenIndex = position356, tokenIndex356
+					{
+						position361 := position
+						if buffer[position] != rune('\'') {
+							goto l360
 						}
 						position++
-						goto l386
-					l387:
-						position, tokenIndex = position387, tokenIndex387
-					}
-					goto l384
-				l385:
-					position, tokenIndex = position384, tokenIndex384
-					if buffer[position] != rune('0') {
-						goto l382
-					}
-					position++
-				}
-			l384:
-				add(ruleuint, position383)
-			}
-			return true
-		l382:
-			position, tokenIndex = position382, tokenIndex382
-			return false
-		},
-		/* 20 col <- <((<uint> Action51) / (<('\'' singlequotedstring '\'')> Action52) / (<('"' doublequotedstring '"')> Action53))> */
-		func() bool {
-			position388, tokenIndex388 := position, tokenIndex
-			{
-				position389 := position
-				{
-					position390, tokenIndex390 := position, tokenIndex
-					{
-						position392 := position
-						if !_rules[ruleuint]() {
-							goto l391
+						if !_rules[rulesinglequotedstring]() {
+							goto l360
 						}
-						add(rulePegText, position392)
+						if buffer[position] != rune('\'') {
+							goto l360
+						}
+						position++
+						add(rulePegText, position361)
 					}
 					{
 						add(ruleAction51, position)
 					}
-					goto l390
-				l391:
-					position, tokenIndex = position390, tokenIndex390
+					goto l356
+				l360:
+					position, tokenIndex = position356, tokenIndex356
 					{
-						position395 := position
-						if buffer[position] != rune('\'') {
-							goto l394
+						position363 := position
+						if buffer[position] != rune('"') {
+							goto l354
 						}
 						position++
-						if !_rules[rulesinglequotedstring]() {
-							goto l394
+						if !_rules[ruledoublequotedstring]() {
+							goto l354
 						}
-						if buffer[position] != rune('\'') {
-							goto l394
+						if buffer[position] != rune('"') {
+							goto l354
 						}
 						position++
-						add(rulePegText, position395)
+						add(rulePegText, position363)
 					}
 					{
 						add(ruleAction52, position)
 					}
-					goto l390
-				l394:
-					position, tokenIndex = position390, tokenIndex390
-					{
-						position397 := position
-						if buffer[position] != rune('"') {
-							goto l388
-						}
-						position++
-						if !_rules[ruledoublequotedstring]() {
-							goto l388
-						}
-						if buffer[position] != rune('"') {
-							goto l388
-						}
-						position++
-						add(rulePegText, position397)
-					}
-					{
-						add(ruleAction53, position)
-					}
 				}
-			l390:
-				add(rulecol, position389)
+			l356:
+				add(rulecol, position355)
 			}
 			return true
-		l388:
-			position, tokenIndex = position388, tokenIndex388
+		l354:
+			position, tokenIndex = position354, tokenIndex354
 			return false
 		},
-		/* 21 row <- <((<uint> Action54) / (<('\'' singlequotedstring '\'')> Action55) / (<('"' doublequotedstring '"')> Action56))> */
+		/* 20 row <- <((<digits> Action53) / (<('\'' singlequotedstring '\'')> Action54) / (<('"' doublequotedstring '"')> Action55))> */
 		nil,
-		/* 22 open <- <('(' sp)> */
+		/* 21 open <- <('(' sp)> */
 		func() bool {
-			position400, tokenIndex400 := position, tokenIndex
+			position366, tokenIndex366 := position, tokenIndex
 			{
-				position401 := position
+				position367 := position
 				if buffer[position] != rune('(') {
-					goto l400
+					goto l366
 				}
 				position++
 				if !_rules[rulesp]() {
-					goto l400
+					goto l366
 				}
-				add(ruleopen, position401)
+				add(ruleopen, position367)
 			}
 			return true
-		l400:
-			position, tokenIndex = position400, tokenIndex400
+		l366:
+			position, tokenIndex = position366, tokenIndex366
 			return false
 		},
-		/* 23 close <- <(sp ')' sp)> */
+		/* 22 close <- <(sp ')' sp)> */
 		func() bool {
-			position402, tokenIndex402 := position, tokenIndex
+			position368, tokenIndex368 := position, tokenIndex
 			{
-				position403 := position
+				position369 := position
 				if !_rules[rulesp]() {
-					goto l402
+					goto l368
 				}
 				if buffer[position] != rune(')') {
-					goto l402
+					goto l368
 				}
 				position++
 				if !_rules[rulesp]() {
-					goto l402
+					goto l368
 				}
-				add(ruleclose, position403)
+				add(ruleclose, position369)
 			}
 			return true
-		l402:
-			position, tokenIndex = position402, tokenIndex402
+		l368:
+			position, tokenIndex = position368, tokenIndex368
 			return false
 		},
-		/* 24 sp <- <(' ' / '\t' / '\n')*> */
+		/* 23 sp <- <(' ' / '\t' / '\n')*> */
 		func() bool {
 			{
-				position405 := position
-			l406:
+				position371 := position
+			l372:
 				{
-					position407, tokenIndex407 := position, tokenIndex
+					position373, tokenIndex373 := position, tokenIndex
 					{
-						position408, tokenIndex408 := position, tokenIndex
+						position374, tokenIndex374 := position, tokenIndex
 						if buffer[position] != rune(' ') {
-							goto l409
+							goto l375
 						}
 						position++
-						goto l408
-					l409:
-						position, tokenIndex = position408, tokenIndex408
+						goto l374
+					l375:
+						position, tokenIndex = position374, tokenIndex374
 						if buffer[position] != rune('\t') {
-							goto l410
+							goto l376
 						}
 						position++
-						goto l408
-					l410:
-						position, tokenIndex = position408, tokenIndex408
+						goto l374
+					l376:
+						position, tokenIndex = position374, tokenIndex374
 						if buffer[position] != rune('\n') {
-							goto l407
+							goto l373
 						}
 						position++
 					}
-				l408:
-					goto l406
-				l407:
-					position, tokenIndex = position407, tokenIndex407
+				l374:
+					goto l372
+				l373:
+					position, tokenIndex = position373, tokenIndex373
 				}
-				add(rulesp, position405)
+				add(rulesp, position371)
 			}
 			return true
 		},
-		/* 25 eq <- <(sp '=' sp)> */
+		/* 24 eq <- <(sp '=' sp)> */
 		func() bool {
-			position411, tokenIndex411 := position, tokenIndex
+			position377, tokenIndex377 := position, tokenIndex
 			{
-				position412 := position
+				position378 := position
 				if !_rules[rulesp]() {
-					goto l411
+					goto l377
 				}
 				if buffer[position] != rune('=') {
-					goto l411
+					goto l377
 				}
 				position++
 				if !_rules[rulesp]() {
-					goto l411
+					goto l377
 				}
-				add(ruleeq, position412)
+				add(ruleeq, position378)
 			}
 			return true
-		l411:
-			position, tokenIndex = position411, tokenIndex411
+		l377:
+			position, tokenIndex = position377, tokenIndex377
 			return false
 		},
-		/* 26 comma <- <(sp ',' sp)> */
+		/* 25 comma <- <(sp ',' sp)> */
 		func() bool {
-			position413, tokenIndex413 := position, tokenIndex
+			position379, tokenIndex379 := position, tokenIndex
 			{
-				position414 := position
+				position380 := position
 				if !_rules[rulesp]() {
-					goto l413
+					goto l379
 				}
 				if buffer[position] != rune(',') {
-					goto l413
+					goto l379
 				}
 				position++
 				if !_rules[rulesp]() {
-					goto l413
+					goto l379
 				}
-				add(rulecomma, position414)
+				add(rulecomma, position380)
 			}
 			return true
-		l413:
-			position, tokenIndex = position413, tokenIndex413
+		l379:
+			position, tokenIndex = position379, tokenIndex379
 			return false
 		},
-		/* 27 lbrack <- <('[' sp)> */
+		/* 26 lbrack <- <('[' sp)> */
 		nil,
-		/* 28 rbrack <- <(sp ']' sp)> */
+		/* 27 rbrack <- <(sp ']' sp)> */
 		nil,
-		/* 29 IDENT <- <(([a-z] / [A-Z]) ([a-z] / [A-Z] / [0-9])*)> */
+		/* 28 IDENT <- <(([a-z] / [A-Z]) ([a-z] / [A-Z] / [0-9])*)> */
 		func() bool {
-			position417, tokenIndex417 := position, tokenIndex
+			position383, tokenIndex383 := position, tokenIndex
 			{
-				position418 := position
+				position384 := position
 				{
-					position419, tokenIndex419 := position, tokenIndex
+					position385, tokenIndex385 := position, tokenIndex
 					if c := buffer[position]; c < rune('a') || c > rune('z') {
-						goto l420
+						goto l386
 					}
 					position++
-					goto l419
-				l420:
-					position, tokenIndex = position419, tokenIndex419
+					goto l385
+				l386:
+					position, tokenIndex = position385, tokenIndex385
 					if c := buffer[position]; c < rune('A') || c > rune('Z') {
-						goto l417
+						goto l383
 					}
 					position++
 				}
-			l419:
-			l421:
+			l385:
+			l387:
 				{
-					position422, tokenIndex422 := position, tokenIndex
+					position388, tokenIndex388 := position, tokenIndex
 					{
-						position423, tokenIndex423 := position, tokenIndex
+						position389, tokenIndex389 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l424
+							goto l390
 						}
 						position++
-						goto l423
-					l424:
-						position, tokenIndex = position423, tokenIndex423
+						goto l389
+					l390:
+						position, tokenIndex = position389, tokenIndex389
 						if c := buffer[position]; c < rune('A') || c > rune('Z') {
-							goto l425
+							goto l391
 						}
 						position++
-						goto l423
-					l425:
-						position, tokenIndex = position423, tokenIndex423
+						goto l389
+					l391:
+						position, tokenIndex = position389, tokenIndex389
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l422
+							goto l388
 						}
 						position++
 					}
-				l423:
-					goto l421
-				l422:
-					position, tokenIndex = position422, tokenIndex422
+				l389:
+					goto l387
+				l388:
+					position, tokenIndex = position388, tokenIndex388
 				}
-				add(ruleIDENT, position418)
+				add(ruleIDENT, position384)
 			}
 			return true
-		l417:
-			position, tokenIndex = position417, tokenIndex417
+		l383:
+			position, tokenIndex = position383, tokenIndex383
 			return false
 		},
-		/* 30 timestampbasicfmt <- <([0-9] [0-9] [0-9] [0-9] '-' ('0' / '1') [0-9] '-' [0-3] [0-9] 'T' [0-9] [0-9] ':' [0-9] [0-9])> */
+		/* 29 digits <- <[0-9]+> */
 		func() bool {
-			position426, tokenIndex426 := position, tokenIndex
+			position392, tokenIndex392 := position, tokenIndex
 			{
-				position427 := position
+				position393 := position
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l426
+					goto l392
+				}
+				position++
+			l394:
+				{
+					position395, tokenIndex395 := position, tokenIndex
+					if c := buffer[position]; c < rune('0') || c > rune('9') {
+						goto l395
+					}
+					position++
+					goto l394
+				l395:
+					position, tokenIndex = position395, tokenIndex395
+				}
+				add(ruledigits, position393)
+			}
+			return true
+		l392:
+			position, tokenIndex = position392, tokenIndex392
+			return false
+		},
+		/* 30 signedDigits <- <('-'? digits)> */
+		nil,
+		/* 31 decimal <- <((signedDigits ('.' digits?)?) / ('-'? '.' digits))> */
+		func() bool {
+			position397, tokenIndex397 := position, tokenIndex
+			{
+				position398 := position
+				{
+					position399, tokenIndex399 := position, tokenIndex
+					{
+						position401 := position
+						{
+							position402, tokenIndex402 := position, tokenIndex
+							if buffer[position] != rune('-') {
+								goto l402
+							}
+							position++
+							goto l403
+						l402:
+							position, tokenIndex = position402, tokenIndex402
+						}
+					l403:
+						if !_rules[ruledigits]() {
+							goto l400
+						}
+						add(rulesignedDigits, position401)
+					}
+					{
+						position404, tokenIndex404 := position, tokenIndex
+						if buffer[position] != rune('.') {
+							goto l404
+						}
+						position++
+						{
+							position406, tokenIndex406 := position, tokenIndex
+							if !_rules[ruledigits]() {
+								goto l406
+							}
+							goto l407
+						l406:
+							position, tokenIndex = position406, tokenIndex406
+						}
+					l407:
+						goto l405
+					l404:
+						position, tokenIndex = position404, tokenIndex404
+					}
+				l405:
+					goto l399
+				l400:
+					position, tokenIndex = position399, tokenIndex399
+					{
+						position408, tokenIndex408 := position, tokenIndex
+						if buffer[position] != rune('-') {
+							goto l408
+						}
+						position++
+						goto l409
+					l408:
+						position, tokenIndex = position408, tokenIndex408
+					}
+				l409:
+					if buffer[position] != rune('.') {
+						goto l397
+					}
+					position++
+					if !_rules[ruledigits]() {
+						goto l397
+					}
+				}
+			l399:
+				add(ruledecimal, position398)
+			}
+			return true
+		l397:
+			position, tokenIndex = position397, tokenIndex397
+			return false
+		},
+		/* 32 timestampbasicfmt <- <([0-9] [0-9] [0-9] [0-9] '-' ('0' / '1') [0-9] '-' [0-3] [0-9] 'T' [0-9] [0-9] ':' [0-9] [0-9])> */
+		func() bool {
+			position410, tokenIndex410 := position, tokenIndex
+			{
+				position411 := position
+				if c := buffer[position]; c < rune('0') || c > rune('9') {
+					goto l410
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l426
+					goto l410
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l426
+					goto l410
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l426
+					goto l410
 				}
 				position++
 				if buffer[position] != rune('-') {
-					goto l426
+					goto l410
 				}
 				position++
 				{
-					position428, tokenIndex428 := position, tokenIndex
+					position412, tokenIndex412 := position, tokenIndex
 					if buffer[position] != rune('0') {
-						goto l429
+						goto l413
 					}
 					position++
-					goto l428
-				l429:
-					position, tokenIndex = position428, tokenIndex428
+					goto l412
+				l413:
+					position, tokenIndex = position412, tokenIndex412
 					if buffer[position] != rune('1') {
-						goto l426
+						goto l410
 					}
 					position++
 				}
-			l428:
+			l412:
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l426
+					goto l410
 				}
 				position++
 				if buffer[position] != rune('-') {
-					goto l426
+					goto l410
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('3') {
-					goto l426
+					goto l410
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l426
+					goto l410
 				}
 				position++
 				if buffer[position] != rune('T') {
-					goto l426
+					goto l410
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l426
+					goto l410
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l426
+					goto l410
 				}
 				position++
 				if buffer[position] != rune(':') {
-					goto l426
+					goto l410
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l426
+					goto l410
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l426
+					goto l410
 				}
 				position++
-				add(ruletimestampbasicfmt, position427)
+				add(ruletimestampbasicfmt, position411)
 			}
 			return true
-		l426:
-			position, tokenIndex = position426, tokenIndex426
+		l410:
+			position, tokenIndex = position410, tokenIndex410
 			return false
 		},
-		/* 31 timestampfmt <- <(('"' <timestampbasicfmt> '"') / ('\'' <timestampbasicfmt> '\'') / <timestampbasicfmt>)> */
+		/* 33 timestampfmt <- <(('"' <timestampbasicfmt> '"') / ('\'' <timestampbasicfmt> '\'') / <timestampbasicfmt>)> */
 		func() bool {
-			position430, tokenIndex430 := position, tokenIndex
+			position414, tokenIndex414 := position, tokenIndex
 			{
-				position431 := position
+				position415 := position
 				{
-					position432, tokenIndex432 := position, tokenIndex
+					position416, tokenIndex416 := position, tokenIndex
 					if buffer[position] != rune('"') {
-						goto l433
+						goto l417
 					}
 					position++
 					{
-						position434 := position
+						position418 := position
 						if !_rules[ruletimestampbasicfmt]() {
-							goto l433
+							goto l417
 						}
-						add(rulePegText, position434)
+						add(rulePegText, position418)
 					}
 					if buffer[position] != rune('"') {
-						goto l433
+						goto l417
 					}
 					position++
-					goto l432
-				l433:
-					position, tokenIndex = position432, tokenIndex432
+					goto l416
+				l417:
+					position, tokenIndex = position416, tokenIndex416
 					if buffer[position] != rune('\'') {
-						goto l435
+						goto l419
 					}
 					position++
 					{
-						position436 := position
+						position420 := position
 						if !_rules[ruletimestampbasicfmt]() {
-							goto l435
+							goto l419
 						}
-						add(rulePegText, position436)
+						add(rulePegText, position420)
 					}
 					if buffer[position] != rune('\'') {
-						goto l435
+						goto l419
 					}
 					position++
-					goto l432
-				l435:
-					position, tokenIndex = position432, tokenIndex432
+					goto l416
+				l419:
+					position, tokenIndex = position416, tokenIndex416
 					{
-						position437 := position
+						position421 := position
 						if !_rules[ruletimestampbasicfmt]() {
-							goto l430
+							goto l414
 						}
-						add(rulePegText, position437)
+						add(rulePegText, position421)
 					}
 				}
-			l432:
-				add(ruletimestampfmt, position431)
+			l416:
+				add(ruletimestampfmt, position415)
 			}
 			return true
-		l430:
-			position, tokenIndex = position430, tokenIndex430
+		l414:
+			position, tokenIndex = position414, tokenIndex414
 			return false
 		},
-		/* 32 timestamp <- <(<timestampfmt> Action57)> */
+		/* 34 timestamp <- <(<timestampfmt> Action56)> */
 		nil,
-		/* 34 Action0 <- <{p.startCall("Set")}> */
+		/* 36 Action0 <- <{p.startCall("Set")}> */
 		nil,
-		/* 35 Action1 <- <{p.endCall()}> */
+		/* 37 Action1 <- <{p.endCall()}> */
 		nil,
-		/* 36 Action2 <- <{p.startCall("SetRowAttrs")}> */
+		/* 38 Action2 <- <{p.startCall("SetRowAttrs")}> */
 		nil,
-		/* 37 Action3 <- <{p.endCall()}> */
+		/* 39 Action3 <- <{p.endCall()}> */
 		nil,
-		/* 38 Action4 <- <{p.startCall("SetColumnAttrs")}> */
+		/* 40 Action4 <- <{p.startCall("SetColumnAttrs")}> */
 		nil,
-		/* 39 Action5 <- <{p.endCall()}> */
+		/* 41 Action5 <- <{p.endCall()}> */
 		nil,
-		/* 40 Action6 <- <{p.startCall("Clear")}> */
+		/* 42 Action6 <- <{p.startCall("Clear")}> */
 		nil,
-		/* 41 Action7 <- <{p.endCall()}> */
+		/* 43 Action7 <- <{p.endCall()}> */
 		nil,
-		/* 42 Action8 <- <{p.startCall("ClearRow")}> */
+		/* 44 Action8 <- <{p.startCall("ClearRow")}> */
 		nil,
-		/* 43 Action9 <- <{p.endCall()}> */
+		/* 45 Action9 <- <{p.endCall()}> */
 		nil,
-		/* 44 Action10 <- <{p.startCall("Store")}> */
+		/* 46 Action10 <- <{p.startCall("Store")}> */
 		nil,
-		/* 45 Action11 <- <{p.endCall()}> */
+		/* 47 Action11 <- <{p.endCall()}> */
 		nil,
-		/* 46 Action12 <- <{p.startCall("TopN")}> */
+		/* 48 Action12 <- <{p.startCall("TopN")}> */
 		nil,
-		/* 47 Action13 <- <{p.endCall()}> */
+		/* 49 Action13 <- <{p.endCall()}> */
 		nil,
-		/* 48 Action14 <- <{p.startCall("Rows")}> */
+		/* 50 Action14 <- <{p.startCall("Rows")}> */
 		nil,
-		/* 49 Action15 <- <{p.endCall()}> */
+		/* 51 Action15 <- <{p.endCall()}> */
 		nil,
-		/* 50 Action16 <- <{p.startCall("Range")}> */
+		/* 52 Action16 <- <{p.startCall("Range")}> */
 		nil,
-		/* 51 Action17 <- <{p.addField("from")}> */
+		/* 53 Action17 <- <{p.addField("from")}> */
 		nil,
-		/* 52 Action18 <- <{p.addVal(text)}> */
+		/* 54 Action18 <- <{p.addVal(text)}> */
 		nil,
-		/* 53 Action19 <- <{p.addField("to")}> */
+		/* 55 Action19 <- <{p.addField("to")}> */
 		nil,
-		/* 54 Action20 <- <{p.addVal(text)}> */
+		/* 56 Action20 <- <{p.addVal(text)}> */
 		nil,
-		/* 55 Action21 <- <{p.endCall()}> */
+		/* 57 Action21 <- <{p.endCall()}> */
 		nil,
 		nil,
-		/* 57 Action22 <- <{ p.startCall(text) }> */
+		/* 59 Action22 <- <{ p.startCall(text) }> */
 		nil,
-		/* 58 Action23 <- <{ p.endCall() }> */
+		/* 60 Action23 <- <{ p.endCall() }> */
 		nil,
-		/* 59 Action24 <- <{ p.addBTWN() }> */
+		/* 61 Action24 <- <{ p.addBTWN() }> */
 		nil,
-		/* 60 Action25 <- <{ p.addLTE() }> */
+		/* 62 Action25 <- <{ p.addLTE() }> */
 		nil,
-		/* 61 Action26 <- <{ p.addGTE() }> */
+		/* 63 Action26 <- <{ p.addGTE() }> */
 		nil,
-		/* 62 Action27 <- <{ p.addEQ() }> */
+		/* 64 Action27 <- <{ p.addEQ() }> */
 		nil,
-		/* 63 Action28 <- <{ p.addNEQ() }> */
+		/* 65 Action28 <- <{ p.addNEQ() }> */
 		nil,
-		/* 64 Action29 <- <{ p.addLT() }> */
+		/* 66 Action29 <- <{ p.addLT() }> */
 		nil,
-		/* 65 Action30 <- <{ p.addGT() }> */
+		/* 67 Action30 <- <{ p.addGT() }> */
 		nil,
-		/* 66 Action31 <- <{p.startConditional()}> */
+		/* 68 Action31 <- <{p.startConditional()}> */
 		nil,
-		/* 67 Action32 <- <{p.endConditional()}> */
+		/* 69 Action32 <- <{p.endConditional()}> */
 		nil,
-		/* 68 Action33 <- <{p.condAdd(text)}> */
+		/* 70 Action33 <- <{p.condAdd(text)}> */
 		nil,
-		/* 69 Action34 <- <{p.condAdd(text)}> */
+		/* 71 Action34 <- <{p.condAdd(text)}> */
 		nil,
-		/* 70 Action35 <- <{p.condAdd(text)}> */
+		/* 72 Action35 <- <{p.condAdd(text)}> */
 		nil,
-		/* 71 Action36 <- <{ p.startList() }> */
+		/* 73 Action36 <- <{ p.startList() }> */
 		nil,
-		/* 72 Action37 <- <{ p.endList() }> */
+		/* 74 Action37 <- <{ p.endList() }> */
 		nil,
-		/* 73 Action38 <- <{ p.addVal(nil) }> */
+		/* 75 Action38 <- <{ p.addVal(nil) }> */
 		nil,
-		/* 74 Action39 <- <{ p.addVal(true) }> */
+		/* 76 Action39 <- <{ p.addVal(true) }> */
 		nil,
-		/* 75 Action40 <- <{ p.addVal(false) }> */
+		/* 77 Action40 <- <{ p.addVal(false) }> */
 		nil,
-		/* 76 Action41 <- <{ p.addVal(text) }> */
+		/* 78 Action41 <- <{ p.addVal(text) }> */
 		nil,
-		/* 77 Action42 <- <{ p.addNumVal(text) }> */
+		/* 79 Action42 <- <{ p.addNumVal(text) }> */
 		nil,
-		/* 78 Action43 <- <{ p.addNumVal(text) }> */
+		/* 80 Action43 <- <{ p.startCall(text) }> */
 		nil,
-		/* 79 Action44 <- <{ p.startCall(text) }> */
+		/* 81 Action44 <- <{ p.addVal(p.endCall()) }> */
 		nil,
-		/* 80 Action45 <- <{ p.addVal(p.endCall()) }> */
+		/* 82 Action45 <- <{ p.addVal(text) }> */
 		nil,
-		/* 81 Action46 <- <{ p.addVal(text) }> */
+		/* 83 Action46 <- <{ p.addVal(text) }> */
 		nil,
-		/* 82 Action47 <- <{ p.addVal(text) }> */
+		/* 84 Action47 <- <{ p.addVal(text) }> */
 		nil,
-		/* 83 Action48 <- <{ p.addVal(text) }> */
+		/* 85 Action48 <- <{ p.addField(text) }> */
 		nil,
-		/* 84 Action49 <- <{ p.addField(text) }> */
+		/* 86 Action49 <- <{ p.addPosStr("_field", text) }> */
 		nil,
-		/* 85 Action50 <- <{ p.addPosStr("_field", text) }> */
+		/* 87 Action50 <- <{p.addPosNum("_col", text)}> */
 		nil,
-		/* 86 Action51 <- <{p.addPosNum("_col", text)}> */
+		/* 88 Action51 <- <{p.addPosStr("_col", text)}> */
 		nil,
-		/* 87 Action52 <- <{p.addPosStr("_col", text)}> */
+		/* 89 Action52 <- <{p.addPosStr("_col", text)}> */
 		nil,
-		/* 88 Action53 <- <{p.addPosStr("_col", text)}> */
+		/* 90 Action53 <- <{p.addPosNum("_row", text)}> */
 		nil,
-		/* 89 Action54 <- <{p.addPosNum("_row", text)}> */
+		/* 91 Action54 <- <{p.addPosStr("_row", text)}> */
 		nil,
-		/* 90 Action55 <- <{p.addPosStr("_row", text)}> */
+		/* 92 Action55 <- <{p.addPosStr("_row", text)}> */
 		nil,
-		/* 91 Action56 <- <{p.addPosStr("_row", text)}> */
-		nil,
-		/* 92 Action57 <- <{p.addPosStr("_timestamp", text)}> */
+		/* 93 Action56 <- <{p.addPosStr("_timestamp", text)}> */
 		nil,
 	}
 	p.rules = _rules