diff --git a/Makefile b/Makefile
index 833535547..84a2be13f 100644
--- a/Makefile
+++ b/Makefile
@@ -236,7 +236,7 @@ topt:
 
 topt-race:
 	mv log.topt.race log.topt.race.prev || true
-	$(eval SHELL:=/bin/bash) set -o pipefail; CGO_ENABLED=1 go test -race -v -tags='$(BUILD_TAGS) $(TEST_TAGS)' $(TESTFLAGS) 2>&1 | tee log.topt.race
+	$(eval SHELL:=/bin/bash) set -o pipefail; CGO_ENABLED=1 go test -race -timeout 60m -v -tags='$(BUILD_TAGS) $(TEST_TAGS)' $(TESTFLAGS) 2>&1 | tee log.topt.race
 	@echo "   log.topt.race green: \c"; cat log.topt.race | grep PASS |wc -l
 	@echo "   log.topt.race   red: \c"; cat log.topt.race | grep '\-\-\- FAIL' | wc -l
 
diff --git a/executor.go b/executor.go
index 85803be68..dcd6ccd12 100644
--- a/executor.go
+++ b/executor.go
@@ -830,6 +830,9 @@ func (e *executor) executeCall(ctx context.Context, qcx *Qcx, index string, c *p
 	case "Limit":
 		res, err := e.executeLimitCall(ctx, qcx, index, c, shards, opt)
 		return res, errors.Wrapf(err, "executeLimitCall %v", shardSlice(shards))
+	case "Percentile":
+		res, err := e.executePercentile(ctx, qcx, index, c, shards, opt)
+		return res, errors.Wrapf(err, "executePercentile %v", shardSlice(shards))
 	default: // e.g. "Row", "Union", "Intersect" or anything that returns a bitmap.
 		statFn()
 		res, err := e.executeBitmapCall(ctx, qcx, index, c, shards, opt)
@@ -1293,6 +1296,119 @@ func (e *executor) executeMax(ctx context.Context, qcx *Qcx, index string, c *pq
 	return other, nil
 }
 
+// executePercentile executes a Percentile() call.
+func (e *executor) executePercentile(ctx context.Context, qcx *Qcx, index string, c *pql.Call, shards []uint64, opt *execOptions) (_ ValCount, err error) {
+	span, ctx := tracing.StartSpanFromContext(ctx, "Executor.executePercentile")
+	defer span.Finish()
+
+	// get nth
+	var nth float64
+	if nthArg, ok := c.Args["nth"].(pql.Decimal); ok {
+		nth = nthArg.Float64()
+		if nth < 0 || nth > 1.0 {
+			return ValCount{}, errors.Errorf("Percentile(): invalid nth value(%f), should be >= 0 and <= 1.0", nth)
+		}
+	} else {
+		return ValCount{}, errors.New("Percentile(): nth required")
+	}
+
+	// get field
+	if fieldArg := c.Args["field"]; fieldArg == "" {
+		return ValCount{}, errors.New("Percentile(): field required")
+	}
+	fieldName, _, _ := c.StringArg("field")
+
+	// filter call for min & max
+	var filterCall *pql.Call
+
+	// check if filter provided
+	if filterArg, ok := c.Args["filter"].(*pql.Call); ok && filterArg != nil {
+		filterCall = filterArg
+	}
+
+	// get min
+	q, _ := pql.ParseString(fmt.Sprintf(`Min(field="%s")`, fieldName))
+	minCall := q.Calls[0]
+	if filterCall != nil {
+		minCall.Children = append(minCall.Children, filterCall)
+	}
+	minVal, err := e.executeMin(ctx, qcx, index, minCall, shards, opt)
+	if err != nil {
+		return ValCount{}, errors.Wrap(err, "executing Min call for Percentile")
+	}
+	if nth == 0.0 {
+		return ValCount{Val: minVal.Val, Count: minVal.Count}, nil
+	}
+
+	// get max
+	q, _ = pql.ParseString(fmt.Sprintf(`Max(field="%s")`, fieldName))
+	maxCall := q.Calls[0]
+	if filterCall != nil {
+		maxCall.Children = append(maxCall.Children, filterCall)
+	}
+	maxVal, err := e.executeMax(ctx, qcx, index, maxCall, shards, opt)
+	if err != nil {
+		return ValCount{}, errors.Wrap(err, "executing Max call for Percentile")
+	}
+	// set up reusables
+	var countCall, rangeCall *pql.Call
+	if filterCall == nil {
+		countQuery, _ := pql.ParseString(fmt.Sprintf("Count(Row(%s < 0))", fieldName))
+		countCall = countQuery.Calls[0]
+		rangeCall = countCall.Children[0]
+	} else {
+		countQuery, _ := pql.ParseString(fmt.Sprintf(`Count(Intersect(Row(%s < 0)))`, fieldName))
+		countCall = countQuery.Calls[0]
+		intersectCall := countCall.Children[0]
+		intersectCall.Children = append(intersectCall.Children, filterCall)
+		rangeCall = intersectCall.Children[0]
+	}
+
+	k := (1 - nth) / nth
+
+	min, max := minVal.Val, maxVal.Val
+	// estimate nth val, eg median when nth=0.5
+	for min < max {
+		possibleNthVal := (max + min) / 2
+		// get left count
+		rangeCall.Args[fieldName] = &pql.Condition{
+			Op:    pql.Token(pql.LT),
+			Value: possibleNthVal,
+		}
+		leftCountUint64, err := e.executeCount(ctx, qcx, index, countCall, shards, opt)
+		if err != nil {
+			return ValCount{}, errors.Wrap(err, "executing Count call L for Percentile")
+		}
+		leftCount := int64(leftCountUint64)
+
+		// get right count
+		rangeCall.Args[fieldName] = &pql.Condition{
+			Op:    pql.Token(pql.GT),
+			Value: possibleNthVal,
+		}
+		rightCountUint64, err := e.executeCount(ctx, qcx, index, countCall, shards, opt)
+		if err != nil {
+			return ValCount{}, errors.Wrap(err, "executing Count call R for Percentile")
+		}
+		rightCount := int64(rightCountUint64)
+
+		// 'weight' the left count as per k
+		leftCountWeighted := int64(math.Round(k * float64(leftCount)))
+
+		// binary search
+		if leftCountWeighted > rightCount {
+			max = possibleNthVal - 1
+		} else if leftCountWeighted < rightCount {
+			min = possibleNthVal + 1
+		} else {
+			return ValCount{Val: possibleNthVal, Count: 1}, nil
+		}
+	}
+
+	return ValCount{Val: min, Count: 1}, nil
+
+}
+
 // executeMinRow executes a MinRow() call.
 func (e *executor) executeMinRow(ctx context.Context, qcx *Qcx, index string, c *pql.Call, shards []uint64, opt *execOptions) (_ interface{}, err error) {
 	span, ctx := tracing.StartSpanFromContext(ctx, "Executor.executeMinRow")
diff --git a/executor_test.go b/executor_test.go
index 10949c4ec..63b015816 100644
--- a/executor_test.go
+++ b/executor_test.go
@@ -25,6 +25,7 @@ import (
 	"io/ioutil"
 	"math"
 	"math/rand"
+	_ "net/http/pprof"
 	"reflect"
 	"sort"
 	"strconv"
@@ -6850,12 +6851,178 @@ func TestVariousQueries(t *testing.T) {
 	for _, clusterSize := range []int{1, 3, 4, 7} {
 		clusterSize := clusterSize
 		t.Run(fmt.Sprintf("%d-node", clusterSize), func(t *testing.T) {
-			t.Parallel()
 			c := test.MustRunCluster(t, clusterSize)
 			defer c.Close()
 
 			variousQueries(t, c)
 			variousQueriesOnTimeFields(t, c)
+			variousQueriesOnPercentiles(t, c)
+		})
+	}
+}
+
+// tests for abbreviating time values in queries
+func variousQueriesOnPercentiles(t *testing.T, c *test.Cluster) {
+	// todo, make rand more random, 42 isnt the answer to everything
+	// however, to make tests reproducible, seed should be printed
+	// on failure?
+	r := rand.New(rand.NewSource(42))
+
+	// gen Numbers to test percentile query on, shuffle for extra spice
+	// size should always be greater than 0
+	type testValue struct {
+		colKey string
+		num    int64
+		rowKey string
+	}
+	size := 100
+
+	testValues := make([]testValue, size)
+	rowKeys := [2]string{"foo", "bar"}
+	for i := 0; i < size; i++ {
+		num := int64(r.Uint32())
+		// flip coin to negate
+		if r.Uint64()%2 == 0 {
+			num = -num
+		}
+		testValues[i] = testValue{
+			colKey: fmt.Sprintf("user%d", i+1),
+			num:    num,
+			rowKey: rowKeys[r.Uint64()%2], // flip a coin
+		}
+	}
+
+	// filter out nums that fulfil predicate
+	var nums []int64
+	for _, v := range testValues {
+		if v.rowKey == "foo" {
+			nums = append(nums, v.num)
+		}
+	}
+
+	// get min and max for calculating both expected median
+	// and bounds for bsi field
+	// get min & max
+
+	// helper function for calculating percentiles to
+	// cross-check with Pilosa's results
+	getExpectedPercentile := func(nums []int64, nth float64) int64 {
+		min, max := nums[0], nums[0]
+		for _, num := range nums {
+			if num < min {
+				min = num
+			}
+			if num > max {
+				max = num
+			}
+		}
+		if nth == 0.0 {
+			return min
+		}
+		k := (1 - nth) / nth
+
+		possibleNthVal := int64(0)
+		// bin search
+		for min < max {
+			possibleNthVal = (max + min) / 2
+			leftCount, rightCount := int64(0), int64(0)
+			for _, num := range nums {
+				if num < possibleNthVal {
+					leftCount++
+				} else if num > possibleNthVal {
+					rightCount++
+				}
+			}
+
+			leftCountWeighted := int64(math.Round(k * float64(leftCount)))
+
+			if leftCountWeighted > rightCount {
+				max = possibleNthVal - 1
+			} else if leftCountWeighted < rightCount {
+				min = possibleNthVal + 1
+			} else { // perfectly balanced, as all things should be
+				return possibleNthVal
+			}
+		}
+		return min
+	}
+
+	// generate numeric entries for index
+	intEntries := make([]test.IntKey, size)
+	for i := 0; i < size; i++ {
+		key := testValues[i].colKey
+		val := testValues[i].num
+		intEntries[i] = test.IntKey{Key: key, Val: val}
+	}
+
+	// generate string-set entries for index
+	var stringEntries [][2]string
+	for _, v := range testValues {
+		stringEntries = append(stringEntries,
+			[2]string{v.rowKey, v.colKey})
+	}
+
+	// get min max for bsi bounds
+	min, max := testValues[0].num, testValues[0].num
+	for _, v := range testValues {
+		if v.num < min {
+			min = v.num
+		}
+		if v.num > max {
+			max = v.num
+		}
+	}
+
+	// generic index
+	c.CreateField(t, "users2", pilosa.IndexOptions{Keys: true, TrackExistence: true}, "net_worth", pilosa.OptFieldTypeInt(min, max))
+	c.ImportIntKey(t, "users2", "net_worth", intEntries)
+
+	c.CreateField(t, "users2", pilosa.IndexOptions{Keys: true, TrackExistence: true}, "val", pilosa.OptFieldKeys())
+	c.ImportKeyKey(t, "users2", "val", stringEntries)
+
+	splitSortBackToCSV := func(csvStr string) string {
+		ss := strings.Split(csvStr[:len(csvStr)-1], "\n")
+		sort.Strings(ss)
+		return strings.Join(ss, "\n") + "\n"
+	}
+
+	type testCase struct {
+		query string
+		// qrVerifier  func(t *testing.T, resp pilosa.QueryResponse)
+		csvVerifier string
+	}
+
+	// generate test cases per each nth argument
+	nths := []float64{0.0, 0.1, 0.25, 0.5, 0.75, 0.9, 0.99}
+	var tests []testCase
+	for _, nth := range nths {
+		query := fmt.Sprintf(`Percentile(field="net_worth", filter=Row(val="foo"), nth=%f)`, nth)
+		expectedPercentile := getExpectedPercentile(nums, nth)
+		tests = append(tests, testCase{
+			query:       query,
+			csvVerifier: fmt.Sprintf("%d,1\n", expectedPercentile),
+		})
+	}
+
+	for i, tst := range tests {
+		t.Run(fmt.Sprintf("%d-%s", i, tst.query), func(t *testing.T) {
+			// resp := c.Query(t, "users2", tst.query)
+			tr := c.QueryGRPC(t, "users2", tst.query)
+			// if tst.qrVerifier != nil {
+			// 	tst.qrVerifier(t, resp)
+			// }
+			csvString, err := tableResponseToCSVString(tr)
+			if err != nil {
+				t.Fatal(err)
+			}
+			// verify everything after header
+			got := splitSortBackToCSV(csvString[strings.Index(csvString, "\n")+1:])
+			if got != tst.csvVerifier {
+				t.Errorf("expected:\n%s\ngot:\n%s", tst.csvVerifier, got)
+			}
+
+			// TODO: add HTTP and Postgres and ability to convert
+			// those results to CSV to run through CSV verifier
 		})
 	}
 }
diff --git a/pql/ast.go b/pql/ast.go
index a4b80f4ae..76272c2ec 100644
--- a/pql/ast.go
+++ b/pql/ast.go
@@ -433,6 +433,14 @@ var callInfoByFunc = map[string]callInfo{
 
 	// things that take _field
 	"TopN": allowUnderField,
+	"Percentile": {
+		allowUnknown: false,
+		prototypes: map[string]interface{}{
+			"field":  "",
+			"filter": nil,
+			"nth":    nil,
+		},
+	},
 	// special cases:
 	"Clear": {
 		allowUnknown: true,
diff --git a/pql/pql.peg b/pql/pql.peg
index ec6241398..13e6bbf23 100644
--- a/pql/pql.peg
+++ b/pql/pql.peg
@@ -14,6 +14,7 @@ Call <-  "Set" {p.startCall("Set")} open col comma args (comma timestamp)? close
        / "Store" {p.startCall("Store")} open Call comma arg close {p.endCall()}
        / "TopN" {p.startCall("TopN")} open posfield (comma allargs)? close {p.endCall()}
        / "TopK" {p.startCall("TopK")} open posfield (comma allargs)? close {p.endCall()}
+       / "Percentile" {p.startCall("Percentile")} open posfield (comma allargs)? close {p.endCall()}       
        / "Rows" {p.startCall("Rows")} open posfield (comma allargs)? close {p.endCall()}
        / "Range" {p.startCall("Range")} open field eq value comma 'from='? {p.addField("from")} timestampfmt {p.addVal(text)} comma 'to='? sp {p.addField("to")} timestampfmt {p.addVal(text)} close {p.endCall()}
        / < IDENT > { p.startCall(text) } open allargs comma? close { p.endCall() }
diff --git a/pql/pql.peg.go b/pql/pql.peg.go
index e761e9e60..3956f42dd 100644
--- a/pql/pql.peg.go
+++ b/pql/pql.peg.go
@@ -76,9 +76,9 @@ const (
 	ruleAction21
 	ruleAction22
 	ruleAction23
-	rulePegText
 	ruleAction24
 	ruleAction25
+	rulePegText
 	ruleAction26
 	ruleAction27
 	ruleAction28
@@ -112,6 +112,8 @@ const (
 	ruleAction56
 	ruleAction57
 	ruleAction58
+	ruleAction59
+	ruleAction60
 )
 
 var rul3s = [...]string{
@@ -175,9 +177,9 @@ var rul3s = [...]string{
 	"Action21",
 	"Action22",
 	"Action23",
-	"PegText",
 	"Action24",
 	"Action25",
+	"PegText",
 	"Action26",
 	"Action27",
 	"Action28",
@@ -211,6 +213,8 @@ var rul3s = [...]string{
 	"Action56",
 	"Action57",
 	"Action58",
+	"Action59",
+	"Action60",
 }
 
 type token32 struct {
@@ -327,7 +331,7 @@ type PQL struct {
 
 	Buffer string
 	buffer []rune
-	rules  [96]func() bool
+	rules  [98]func() bool
 	parse  func(rule ...int) error
 	reset  func()
 	Pretty bool
@@ -456,90 +460,94 @@ func (p *PQL) Execute() {
 		case ruleAction15:
 			p.endCall()
 		case ruleAction16:
-			p.startCall("Rows")
+			p.startCall("Percentile")
 		case ruleAction17:
 			p.endCall()
 		case ruleAction18:
-			p.startCall("Range")
+			p.startCall("Rows")
 		case ruleAction19:
-			p.addField("from")
+			p.endCall()
 		case ruleAction20:
-			p.addVal(text)
+			p.startCall("Range")
 		case ruleAction21:
-			p.addField("to")
+			p.addField("from")
 		case ruleAction22:
 			p.addVal(text)
 		case ruleAction23:
-			p.endCall()
+			p.addField("to")
 		case ruleAction24:
-			p.startCall(text)
+			p.addVal(text)
 		case ruleAction25:
 			p.endCall()
 		case ruleAction26:
-			p.addBTWN()
+			p.startCall(text)
 		case ruleAction27:
-			p.addLTE()
+			p.endCall()
 		case ruleAction28:
-			p.addGTE()
+			p.addBTWN()
 		case ruleAction29:
-			p.addEQ()
+			p.addLTE()
 		case ruleAction30:
-			p.addNEQ()
+			p.addGTE()
 		case ruleAction31:
-			p.addLT()
+			p.addEQ()
 		case ruleAction32:
-			p.addGT()
+			p.addNEQ()
 		case ruleAction33:
-			p.startConditional()
+			p.addLT()
 		case ruleAction34:
-			p.endConditional()
+			p.addGT()
 		case ruleAction35:
-			p.condAdd(text)
+			p.startConditional()
 		case ruleAction36:
-			p.condAdd(text)
+			p.endConditional()
 		case ruleAction37:
 			p.condAdd(text)
 		case ruleAction38:
-			p.startList()
+			p.condAdd(text)
 		case ruleAction39:
-			p.endList()
+			p.condAdd(text)
 		case ruleAction40:
-			p.addVal(nil)
+			p.startList()
 		case ruleAction41:
-			p.addVal(true)
+			p.endList()
 		case ruleAction42:
-			p.addVal(false)
+			p.addVal(nil)
 		case ruleAction43:
-			p.addVal(text)
+			p.addVal(true)
 		case ruleAction44:
-			p.addNumVal(text)
+			p.addVal(false)
 		case ruleAction45:
-			p.startCall(text)
+			p.addVal(text)
 		case ruleAction46:
-			p.addVal(p.endCall())
+			p.addNumVal(text)
 		case ruleAction47:
-			p.addVal(text)
+			p.startCall(text)
 		case ruleAction48:
-			p.addVal(text)
+			p.addVal(p.endCall())
 		case ruleAction49:
 			p.addVal(text)
 		case ruleAction50:
-			p.addField(text)
+			p.addVal(text)
 		case ruleAction51:
-			p.addPosStr("_field", text)
+			p.addVal(text)
 		case ruleAction52:
-			p.addPosNum("_col", text)
+			p.addField(text)
 		case ruleAction53:
-			p.addPosStr("_col", text)
+			p.addPosStr("_field", text)
 		case ruleAction54:
-			p.addPosStr("_col", text)
+			p.addPosNum("_col", text)
 		case ruleAction55:
-			p.addPosNum("_row", text)
+			p.addPosStr("_col", text)
 		case ruleAction56:
-			p.addPosStr("_row", text)
+			p.addPosStr("_col", text)
 		case ruleAction57:
-			p.addPosStr("_row", text)
+			p.addPosNum("_row", text)
 		case ruleAction58:
+			p.addPosStr("_row", text)
+		case ruleAction59:
+			p.addPosStr("_row", text)
+		case ruleAction60:
 			p.addPosStr("_timestamp", text)
 
 		}
@@ -671,7 +679,7 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 			position, tokenIndex = position0, tokenIndex0
 			return false
 		},
-		/* 1 Call <- <((('s' / 'S') ('e' / 'E') ('t' / 'T') Action0 open col comma args (comma timestamp)? close Action1) / (('s' / 'S') ('e' / 'E') ('t' / 'T') ('r' / 'R') ('o' / 'O') ('w' / 'W') ('a' / 'A') ('t' / 'T') ('t' / 'T') ('r' / 'R') ('s' / 'S') Action2 open posfield comma row comma args close Action3) / (('s' / 'S') ('e' / 'E') ('t' / 'T') ('c' / 'C') ('o' / 'O') ('l' / 'L') ('u' / 'U') ('m' / 'M') ('n' / 'N') ('a' / 'A') ('t' / 'T') ('t' / 'T') ('r' / 'R') ('s' / 'S') Action4 open col comma args close Action5) / (('c' / 'C') ('l' / 'L') ('e' / 'E') ('a' / 'A') ('r' / 'R') Action6 open col comma args close Action7) / (('c' / 'C') ('l' / 'L') ('e' / 'E') ('a' / 'A') ('r' / 'R') ('r' / 'R') ('o' / 'O') ('w' / 'W') Action8 open arg close Action9) / (('s' / 'S') ('t' / 'T') ('o' / 'O') ('r' / 'R') ('e' / 'E') Action10 open Call comma arg close Action11) / (('t' / 'T') ('o' / 'O') ('p' / 'P') ('n' / 'N') Action12 open posfield (comma allargs)? close Action13) / (('t' / 'T') ('o' / 'O') ('p' / 'P') ('k' / 'K') Action14 open posfield (comma allargs)? close Action15) / (('r' / 'R') ('o' / 'O') ('w' / 'W') ('s' / 'S') Action16 open posfield (comma allargs)? close Action17) / (('r' / 'R') ('a' / 'A') ('n' / 'N') ('g' / 'G') ('e' / 'E') Action18 open field eq value comma ('f' 'r' 'o' 'm' '=')? Action19 timestampfmt Action20 comma ('t' 'o' '=')? sp Action21 timestampfmt Action22 close Action23) / (<IDENT> Action24 open allargs comma? close Action25))> */
+		/* 1 Call <- <((('s' / 'S') ('e' / 'E') ('t' / 'T') Action0 open col comma args (comma timestamp)? close Action1) / (('s' / 'S') ('e' / 'E') ('t' / 'T') ('r' / 'R') ('o' / 'O') ('w' / 'W') ('a' / 'A') ('t' / 'T') ('t' / 'T') ('r' / 'R') ('s' / 'S') Action2 open posfield comma row comma args close Action3) / (('s' / 'S') ('e' / 'E') ('t' / 'T') ('c' / 'C') ('o' / 'O') ('l' / 'L') ('u' / 'U') ('m' / 'M') ('n' / 'N') ('a' / 'A') ('t' / 'T') ('t' / 'T') ('r' / 'R') ('s' / 'S') Action4 open col comma args close Action5) / (('c' / 'C') ('l' / 'L') ('e' / 'E') ('a' / 'A') ('r' / 'R') Action6 open col comma args close Action7) / (('c' / 'C') ('l' / 'L') ('e' / 'E') ('a' / 'A') ('r' / 'R') ('r' / 'R') ('o' / 'O') ('w' / 'W') Action8 open arg close Action9) / (('s' / 'S') ('t' / 'T') ('o' / 'O') ('r' / 'R') ('e' / 'E') Action10 open Call comma arg close Action11) / (('t' / 'T') ('o' / 'O') ('p' / 'P') ('n' / 'N') Action12 open posfield (comma allargs)? close Action13) / (('t' / 'T') ('o' / 'O') ('p' / 'P') ('k' / 'K') Action14 open posfield (comma allargs)? close Action15) / (('p' / 'P') ('e' / 'E') ('r' / 'R') ('c' / 'C') ('e' / 'E') ('n' / 'N') ('t' / 'T') ('i' / 'I') ('l' / 'L') ('e' / 'E') Action16 open posfield (comma allargs)? close Action17) / (('r' / 'R') ('o' / 'O') ('w' / 'W') ('s' / 'S') Action18 open posfield (comma allargs)? close Action19) / (('r' / 'R') ('a' / 'A') ('n' / 'N') ('g' / 'G') ('e' / 'E') Action20 open field eq value comma ('f' 'r' 'o' 'm' '=')? Action21 timestampfmt Action22 comma ('t' 'o' '=')? sp Action23 timestampfmt Action24 close Action25) / (<IDENT> Action26 open allargs comma? close Action27))> */
 		func() bool {
 			position5, tokenIndex5 := position, tokenIndex
 			{
@@ -753,7 +761,7 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 								add(rulePegText, position19)
 							}
 							{
-								add(ruleAction58, position)
+								add(ruleAction60, position)
 							}
 							add(ruletimestamp, position18)
 						}
@@ -960,7 +968,7 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 								add(rulePegText, position49)
 							}
 							{
-								add(ruleAction55, position)
+								add(ruleAction57, position)
 							}
 							goto l47
 						l48:
@@ -981,7 +989,7 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 								add(rulePegText, position52)
 							}
 							{
-								add(ruleAction56, position)
+								add(ruleAction58, position)
 							}
 							goto l47
 						l51:
@@ -1002,7 +1010,7 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 								add(rulePegText, position54)
 							}
 							{
-								add(ruleAction57, position)
+								add(ruleAction59, position)
 							}
 						}
 					l47:
@@ -1777,14 +1785,14 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 					position, tokenIndex = position7, tokenIndex7
 					{
 						position160, tokenIndex160 := position, tokenIndex
-						if buffer[position] != rune('r') {
+						if buffer[position] != rune('p') {
 							goto l161
 						}
 						position++
 						goto l160
 					l161:
 						position, tokenIndex = position160, tokenIndex160
-						if buffer[position] != rune('R') {
+						if buffer[position] != rune('P') {
 							goto l159
 						}
 						position++
@@ -1792,14 +1800,14 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 				l160:
 					{
 						position162, tokenIndex162 := position, tokenIndex
-						if buffer[position] != rune('o') {
+						if buffer[position] != rune('e') {
 							goto l163
 						}
 						position++
 						goto l162
 					l163:
 						position, tokenIndex = position162, tokenIndex162
-						if buffer[position] != rune('O') {
+						if buffer[position] != rune('E') {
 							goto l159
 						}
 						position++
@@ -1807,14 +1815,14 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 				l162:
 					{
 						position164, tokenIndex164 := position, tokenIndex
-						if buffer[position] != rune('w') {
+						if buffer[position] != rune('r') {
 							goto l165
 						}
 						position++
 						goto l164
 					l165:
 						position, tokenIndex = position164, tokenIndex164
-						if buffer[position] != rune('W') {
+						if buffer[position] != rune('R') {
 							goto l159
 						}
 						position++
@@ -1822,19 +1830,109 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 				l164:
 					{
 						position166, tokenIndex166 := position, tokenIndex
-						if buffer[position] != rune('s') {
+						if buffer[position] != rune('c') {
 							goto l167
 						}
 						position++
 						goto l166
 					l167:
 						position, tokenIndex = position166, tokenIndex166
-						if buffer[position] != rune('S') {
+						if buffer[position] != rune('C') {
 							goto l159
 						}
 						position++
 					}
 				l166:
+					{
+						position168, tokenIndex168 := position, tokenIndex
+						if buffer[position] != rune('e') {
+							goto l169
+						}
+						position++
+						goto l168
+					l169:
+						position, tokenIndex = position168, tokenIndex168
+						if buffer[position] != rune('E') {
+							goto l159
+						}
+						position++
+					}
+				l168:
+					{
+						position170, tokenIndex170 := position, tokenIndex
+						if buffer[position] != rune('n') {
+							goto l171
+						}
+						position++
+						goto l170
+					l171:
+						position, tokenIndex = position170, tokenIndex170
+						if buffer[position] != rune('N') {
+							goto l159
+						}
+						position++
+					}
+				l170:
+					{
+						position172, tokenIndex172 := position, tokenIndex
+						if buffer[position] != rune('t') {
+							goto l173
+						}
+						position++
+						goto l172
+					l173:
+						position, tokenIndex = position172, tokenIndex172
+						if buffer[position] != rune('T') {
+							goto l159
+						}
+						position++
+					}
+				l172:
+					{
+						position174, tokenIndex174 := position, tokenIndex
+						if buffer[position] != rune('i') {
+							goto l175
+						}
+						position++
+						goto l174
+					l175:
+						position, tokenIndex = position174, tokenIndex174
+						if buffer[position] != rune('I') {
+							goto l159
+						}
+						position++
+					}
+				l174:
+					{
+						position176, tokenIndex176 := position, tokenIndex
+						if buffer[position] != rune('l') {
+							goto l177
+						}
+						position++
+						goto l176
+					l177:
+						position, tokenIndex = position176, tokenIndex176
+						if buffer[position] != rune('L') {
+							goto l159
+						}
+						position++
+					}
+				l176:
+					{
+						position178, tokenIndex178 := position, tokenIndex
+						if buffer[position] != rune('e') {
+							goto l179
+						}
+						position++
+						goto l178
+					l179:
+						position, tokenIndex = position178, tokenIndex178
+						if buffer[position] != rune('E') {
+							goto l159
+						}
+						position++
+					}
+				l178:
 					{
 						add(ruleAction16, position)
 					}
@@ -1845,18 +1943,18 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 						goto l159
 					}
 					{
-						position169, tokenIndex169 := position, tokenIndex
+						position181, tokenIndex181 := position, tokenIndex
 						if !_rules[rulecomma]() {
-							goto l169
+							goto l181
 						}
 						if !_rules[ruleallargs]() {
-							goto l169
+							goto l181
 						}
-						goto l170
-					l169:
-						position, tokenIndex = position169, tokenIndex169
+						goto l182
+					l181:
+						position, tokenIndex = position181, tokenIndex181
 					}
-				l170:
+				l182:
 					if !_rules[ruleclose]() {
 						goto l159
 					}
@@ -1867,187 +1965,278 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 				l159:
 					position, tokenIndex = position7, tokenIndex7
 					{
-						position173, tokenIndex173 := position, tokenIndex
+						position185, tokenIndex185 := position, tokenIndex
 						if buffer[position] != rune('r') {
-							goto l174
+							goto l186
 						}
 						position++
-						goto l173
-					l174:
-						position, tokenIndex = position173, tokenIndex173
+						goto l185
+					l186:
+						position, tokenIndex = position185, tokenIndex185
 						if buffer[position] != rune('R') {
-							goto l172
+							goto l184
 						}
 						position++
 					}
-				l173:
+				l185:
 					{
-						position175, tokenIndex175 := position, tokenIndex
-						if buffer[position] != rune('a') {
-							goto l176
+						position187, tokenIndex187 := position, tokenIndex
+						if buffer[position] != rune('o') {
+							goto l188
 						}
 						position++
-						goto l175
-					l176:
-						position, tokenIndex = position175, tokenIndex175
-						if buffer[position] != rune('A') {
-							goto l172
+						goto l187
+					l188:
+						position, tokenIndex = position187, tokenIndex187
+						if buffer[position] != rune('O') {
+							goto l184
 						}
 						position++
 					}
-				l175:
+				l187:
 					{
-						position177, tokenIndex177 := position, tokenIndex
-						if buffer[position] != rune('n') {
-							goto l178
+						position189, tokenIndex189 := position, tokenIndex
+						if buffer[position] != rune('w') {
+							goto l190
 						}
 						position++
-						goto l177
-					l178:
-						position, tokenIndex = position177, tokenIndex177
-						if buffer[position] != rune('N') {
-							goto l172
+						goto l189
+					l190:
+						position, tokenIndex = position189, tokenIndex189
+						if buffer[position] != rune('W') {
+							goto l184
 						}
 						position++
 					}
-				l177:
+				l189:
 					{
-						position179, tokenIndex179 := position, tokenIndex
-						if buffer[position] != rune('g') {
-							goto l180
+						position191, tokenIndex191 := position, tokenIndex
+						if buffer[position] != rune('s') {
+							goto l192
 						}
 						position++
-						goto l179
-					l180:
-						position, tokenIndex = position179, tokenIndex179
-						if buffer[position] != rune('G') {
-							goto l172
+						goto l191
+					l192:
+						position, tokenIndex = position191, tokenIndex191
+						if buffer[position] != rune('S') {
+							goto l184
 						}
 						position++
 					}
-				l179:
-					{
-						position181, tokenIndex181 := position, tokenIndex
-						if buffer[position] != rune('e') {
-							goto l182
-						}
-						position++
-						goto l181
-					l182:
-						position, tokenIndex = position181, tokenIndex181
-						if buffer[position] != rune('E') {
-							goto l172
-						}
-						position++
-					}
-				l181:
+				l191:
 					{
 						add(ruleAction18, position)
 					}
 					if !_rules[ruleopen]() {
-						goto l172
+						goto l184
 					}
-					if !_rules[rulefield]() {
-						goto l172
-					}
-					if !_rules[ruleeq]() {
-						goto l172
-					}
-					if !_rules[rulevalue]() {
-						goto l172
-					}
-					if !_rules[rulecomma]() {
-						goto l172
+					if !_rules[ruleposfield]() {
+						goto l184
 					}
 					{
-						position184, tokenIndex184 := position, tokenIndex
-						if buffer[position] != rune('f') {
-							goto l184
+						position194, tokenIndex194 := position, tokenIndex
+						if !_rules[rulecomma]() {
+							goto l194
 						}
-						position++
-						if buffer[position] != rune('r') {
-							goto l184
+						if !_rules[ruleallargs]() {
+							goto l194
 						}
-						position++
-						if buffer[position] != rune('o') {
-							goto l184
-						}
-						position++
-						if buffer[position] != rune('m') {
-							goto l184
-						}
-						position++
-						if buffer[position] != rune('=') {
-							goto l184
-						}
-						position++
-						goto l185
-					l184:
-						position, tokenIndex = position184, tokenIndex184
+						goto l195
+					l194:
+						position, tokenIndex = position194, tokenIndex194
+					}
+				l195:
+					if !_rules[ruleclose]() {
+						goto l184
 					}
-				l185:
 					{
 						add(ruleAction19, position)
 					}
-					if !_rules[ruletimestampfmt]() {
-						goto l172
+					goto l7
+				l184:
+					position, tokenIndex = position7, tokenIndex7
+					{
+						position198, tokenIndex198 := position, tokenIndex
+						if buffer[position] != rune('r') {
+							goto l199
+						}
+						position++
+						goto l198
+					l199:
+						position, tokenIndex = position198, tokenIndex198
+						if buffer[position] != rune('R') {
+							goto l197
+						}
+						position++
 					}
+				l198:
+					{
+						position200, tokenIndex200 := position, tokenIndex
+						if buffer[position] != rune('a') {
+							goto l201
+						}
+						position++
+						goto l200
+					l201:
+						position, tokenIndex = position200, tokenIndex200
+						if buffer[position] != rune('A') {
+							goto l197
+						}
+						position++
+					}
+				l200:
+					{
+						position202, tokenIndex202 := position, tokenIndex
+						if buffer[position] != rune('n') {
+							goto l203
+						}
+						position++
+						goto l202
+					l203:
+						position, tokenIndex = position202, tokenIndex202
+						if buffer[position] != rune('N') {
+							goto l197
+						}
+						position++
+					}
+				l202:
+					{
+						position204, tokenIndex204 := position, tokenIndex
+						if buffer[position] != rune('g') {
+							goto l205
+						}
+						position++
+						goto l204
+					l205:
+						position, tokenIndex = position204, tokenIndex204
+						if buffer[position] != rune('G') {
+							goto l197
+						}
+						position++
+					}
+				l204:
+					{
+						position206, tokenIndex206 := position, tokenIndex
+						if buffer[position] != rune('e') {
+							goto l207
+						}
+						position++
+						goto l206
+					l207:
+						position, tokenIndex = position206, tokenIndex206
+						if buffer[position] != rune('E') {
+							goto l197
+						}
+						position++
+					}
+				l206:
 					{
 						add(ruleAction20, position)
 					}
+					if !_rules[ruleopen]() {
+						goto l197
+					}
+					if !_rules[rulefield]() {
+						goto l197
+					}
+					if !_rules[ruleeq]() {
+						goto l197
+					}
+					if !_rules[rulevalue]() {
+						goto l197
+					}
 					if !_rules[rulecomma]() {
-						goto l172
+						goto l197
 					}
 					{
-						position188, tokenIndex188 := position, tokenIndex
-						if buffer[position] != rune('t') {
-							goto l188
+						position209, tokenIndex209 := position, tokenIndex
+						if buffer[position] != rune('f') {
+							goto l209
+						}
+						position++
+						if buffer[position] != rune('r') {
+							goto l209
 						}
 						position++
 						if buffer[position] != rune('o') {
-							goto l188
+							goto l209
+						}
+						position++
+						if buffer[position] != rune('m') {
+							goto l209
 						}
 						position++
 						if buffer[position] != rune('=') {
-							goto l188
+							goto l209
 						}
 						position++
-						goto l189
-					l188:
-						position, tokenIndex = position188, tokenIndex188
-					}
-				l189:
-					if !_rules[rulesp]() {
-						goto l172
+						goto l210
+					l209:
+						position, tokenIndex = position209, tokenIndex209
 					}
+				l210:
 					{
 						add(ruleAction21, position)
 					}
 					if !_rules[ruletimestampfmt]() {
-						goto l172
+						goto l197
 					}
 					{
 						add(ruleAction22, position)
 					}
-					if !_rules[ruleclose]() {
-						goto l172
+					if !_rules[rulecomma]() {
+						goto l197
+					}
+					{
+						position213, tokenIndex213 := position, tokenIndex
+						if buffer[position] != rune('t') {
+							goto l213
+						}
+						position++
+						if buffer[position] != rune('o') {
+							goto l213
+						}
+						position++
+						if buffer[position] != rune('=') {
+							goto l213
+						}
+						position++
+						goto l214
+					l213:
+						position, tokenIndex = position213, tokenIndex213
+					}
+				l214:
+					if !_rules[rulesp]() {
+						goto l197
 					}
 					{
 						add(ruleAction23, position)
 					}
-					goto l7
-				l172:
-					position, tokenIndex = position7, tokenIndex7
-					{
-						position193 := position
-						if !_rules[ruleIDENT]() {
-							goto l5
-						}
-						add(rulePegText, position193)
+					if !_rules[ruletimestampfmt]() {
+						goto l197
 					}
 					{
 						add(ruleAction24, position)
 					}
+					if !_rules[ruleclose]() {
+						goto l197
+					}
+					{
+						add(ruleAction25, position)
+					}
+					goto l7
+				l197:
+					position, tokenIndex = position7, tokenIndex7
+					{
+						position218 := position
+						if !_rules[ruleIDENT]() {
+							goto l5
+						}
+						add(rulePegText, position218)
+					}
+					{
+						add(ruleAction26, position)
+					}
 					if !_rules[ruleopen]() {
 						goto l5
 					}
@@ -2055,20 +2244,20 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 						goto l5
 					}
 					{
-						position195, tokenIndex195 := position, tokenIndex
+						position220, tokenIndex220 := position, tokenIndex
 						if !_rules[rulecomma]() {
-							goto l195
+							goto l220
 						}
-						goto l196
-					l195:
-						position, tokenIndex = position195, tokenIndex195
+						goto l221
+					l220:
+						position, tokenIndex = position220, tokenIndex220
 					}
-				l196:
+				l221:
 					if !_rules[ruleclose]() {
 						goto l5
 					}
 					{
-						add(ruleAction25, position)
+						add(ruleAction27, position)
 					}
 				}
 			l7:
@@ -2081,1414 +2270,1414 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 		},
 		/* 2 allargs <- <((Call (comma Call)* (comma args)?) / args / sp)> */
 		func() bool {
-			position198, tokenIndex198 := position, tokenIndex
+			position223, tokenIndex223 := position, tokenIndex
 			{
-				position199 := position
+				position224 := position
 				{
-					position200, tokenIndex200 := position, tokenIndex
+					position225, tokenIndex225 := position, tokenIndex
 					if !_rules[ruleCall]() {
-						goto l201
+						goto l226
 					}
-				l202:
+				l227:
 					{
-						position203, tokenIndex203 := position, tokenIndex
+						position228, tokenIndex228 := position, tokenIndex
 						if !_rules[rulecomma]() {
-							goto l203
+							goto l228
 						}
 						if !_rules[ruleCall]() {
-							goto l203
+							goto l228
 						}
-						goto l202
-					l203:
-						position, tokenIndex = position203, tokenIndex203
+						goto l227
+					l228:
+						position, tokenIndex = position228, tokenIndex228
 					}
 					{
-						position204, tokenIndex204 := position, tokenIndex
+						position229, tokenIndex229 := position, tokenIndex
 						if !_rules[rulecomma]() {
-							goto l204
+							goto l229
 						}
 						if !_rules[ruleargs]() {
-							goto l204
+							goto l229
 						}
-						goto l205
-					l204:
-						position, tokenIndex = position204, tokenIndex204
+						goto l230
+					l229:
+						position, tokenIndex = position229, tokenIndex229
 					}
-				l205:
-					goto l200
-				l201:
-					position, tokenIndex = position200, tokenIndex200
+				l230:
+					goto l225
+				l226:
+					position, tokenIndex = position225, tokenIndex225
 					if !_rules[ruleargs]() {
-						goto l206
+						goto l231
 					}
-					goto l200
-				l206:
-					position, tokenIndex = position200, tokenIndex200
+					goto l225
+				l231:
+					position, tokenIndex = position225, tokenIndex225
 					if !_rules[rulesp]() {
-						goto l198
+						goto l223
 					}
 				}
-			l200:
-				add(ruleallargs, position199)
+			l225:
+				add(ruleallargs, position224)
 			}
 			return true
-		l198:
-			position, tokenIndex = position198, tokenIndex198
+		l223:
+			position, tokenIndex = position223, tokenIndex223
 			return false
 		},
 		/* 3 args <- <(arg (comma args)? sp)> */
 		func() bool {
-			position207, tokenIndex207 := position, tokenIndex
+			position232, tokenIndex232 := position, tokenIndex
 			{
-				position208 := position
+				position233 := position
 				if !_rules[rulearg]() {
-					goto l207
+					goto l232
 				}
 				{
-					position209, tokenIndex209 := position, tokenIndex
+					position234, tokenIndex234 := position, tokenIndex
 					if !_rules[rulecomma]() {
-						goto l209
+						goto l234
 					}
 					if !_rules[ruleargs]() {
-						goto l209
+						goto l234
 					}
-					goto l210
-				l209:
-					position, tokenIndex = position209, tokenIndex209
+					goto l235
+				l234:
+					position, tokenIndex = position234, tokenIndex234
 				}
-			l210:
+			l235:
 				if !_rules[rulesp]() {
-					goto l207
+					goto l232
 				}
-				add(ruleargs, position208)
+				add(ruleargs, position233)
 			}
 			return true
-		l207:
-			position, tokenIndex = position207, tokenIndex207
+		l232:
+			position, tokenIndex = position232, tokenIndex232
 			return false
 		},
 		/* 4 arg <- <((field eq value) / (field sp COND sp value) / conditional)> */
 		func() bool {
-			position211, tokenIndex211 := position, tokenIndex
+			position236, tokenIndex236 := position, tokenIndex
 			{
-				position212 := position
+				position237 := position
 				{
-					position213, tokenIndex213 := position, tokenIndex
+					position238, tokenIndex238 := position, tokenIndex
 					if !_rules[rulefield]() {
-						goto l214
+						goto l239
 					}
 					if !_rules[ruleeq]() {
-						goto l214
+						goto l239
 					}
 					if !_rules[rulevalue]() {
-						goto l214
+						goto l239
 					}
-					goto l213
-				l214:
-					position, tokenIndex = position213, tokenIndex213
+					goto l238
+				l239:
+					position, tokenIndex = position238, tokenIndex238
 					if !_rules[rulefield]() {
-						goto l215
+						goto l240
 					}
 					if !_rules[rulesp]() {
-						goto l215
+						goto l240
 					}
 					{
-						position216 := position
+						position241 := position
 						{
-							position217, tokenIndex217 := position, tokenIndex
+							position242, tokenIndex242 := position, tokenIndex
 							if buffer[position] != rune('>') {
-								goto l218
+								goto l243
 							}
 							position++
 							if buffer[position] != rune('<') {
-								goto l218
-							}
-							position++
-							{
-								add(ruleAction26, position)
-							}
-							goto l217
-						l218:
-							position, tokenIndex = position217, tokenIndex217
-							if buffer[position] != rune('<') {
-								goto l220
-							}
-							position++
-							if buffer[position] != rune('=') {
-								goto l220
-							}
-							position++
-							{
-								add(ruleAction27, position)
-							}
-							goto l217
-						l220:
-							position, tokenIndex = position217, tokenIndex217
-							if buffer[position] != rune('>') {
-								goto l222
-							}
-							position++
-							if buffer[position] != rune('=') {
-								goto l222
+								goto l243
 							}
 							position++
 							{
 								add(ruleAction28, position)
 							}
-							goto l217
-						l222:
-							position, tokenIndex = position217, tokenIndex217
-							if buffer[position] != rune('=') {
-								goto l224
+							goto l242
+						l243:
+							position, tokenIndex = position242, tokenIndex242
+							if buffer[position] != rune('<') {
+								goto l245
 							}
 							position++
 							if buffer[position] != rune('=') {
-								goto l224
+								goto l245
 							}
 							position++
 							{
 								add(ruleAction29, position)
 							}
-							goto l217
-						l224:
-							position, tokenIndex = position217, tokenIndex217
-							if buffer[position] != rune('!') {
-								goto l226
+							goto l242
+						l245:
+							position, tokenIndex = position242, tokenIndex242
+							if buffer[position] != rune('>') {
+								goto l247
 							}
 							position++
 							if buffer[position] != rune('=') {
-								goto l226
+								goto l247
 							}
 							position++
 							{
 								add(ruleAction30, position)
 							}
-							goto l217
-						l226:
-							position, tokenIndex = position217, tokenIndex217
-							if buffer[position] != rune('<') {
-								goto l228
+							goto l242
+						l247:
+							position, tokenIndex = position242, tokenIndex242
+							if buffer[position] != rune('=') {
+								goto l249
+							}
+							position++
+							if buffer[position] != rune('=') {
+								goto l249
 							}
 							position++
 							{
 								add(ruleAction31, position)
 							}
-							goto l217
-						l228:
-							position, tokenIndex = position217, tokenIndex217
-							if buffer[position] != rune('>') {
-								goto l215
+							goto l242
+						l249:
+							position, tokenIndex = position242, tokenIndex242
+							if buffer[position] != rune('!') {
+								goto l251
+							}
+							position++
+							if buffer[position] != rune('=') {
+								goto l251
 							}
 							position++
 							{
 								add(ruleAction32, position)
 							}
+							goto l242
+						l251:
+							position, tokenIndex = position242, tokenIndex242
+							if buffer[position] != rune('<') {
+								goto l253
+							}
+							position++
+							{
+								add(ruleAction33, position)
+							}
+							goto l242
+						l253:
+							position, tokenIndex = position242, tokenIndex242
+							if buffer[position] != rune('>') {
+								goto l240
+							}
+							position++
+							{
+								add(ruleAction34, position)
+							}
 						}
-					l217:
-						add(ruleCOND, position216)
+					l242:
+						add(ruleCOND, position241)
 					}
 					if !_rules[rulesp]() {
-						goto l215
+						goto l240
 					}
 					if !_rules[rulevalue]() {
-						goto l215
+						goto l240
 					}
-					goto l213
-				l215:
-					position, tokenIndex = position213, tokenIndex213
+					goto l238
+				l240:
+					position, tokenIndex = position238, tokenIndex238
 					{
-						position231 := position
+						position256 := position
 						{
-							add(ruleAction33, position)
+							add(ruleAction35, position)
 						}
 						if !_rules[rulecondint]() {
-							goto l211
+							goto l236
 						}
 						if !_rules[rulecondLT]() {
-							goto l211
+							goto l236
 						}
 						{
-							position233 := position
+							position258 := position
 							{
-								position234 := position
+								position259 := position
 								if !_rules[rulefieldExpr]() {
-									goto l211
+									goto l236
 								}
-								add(rulePegText, position234)
+								add(rulePegText, position259)
 							}
 							if !_rules[rulesp]() {
-								goto l211
+								goto l236
 							}
 							{
-								add(ruleAction37, position)
+								add(ruleAction39, position)
 							}
-							add(rulecondfield, position233)
+							add(rulecondfield, position258)
 						}
 						if !_rules[rulecondLT]() {
-							goto l211
+							goto l236
 						}
 						if !_rules[rulecondint]() {
-							goto l211
+							goto l236
 						}
 						{
-							add(ruleAction34, position)
+							add(ruleAction36, position)
 						}
-						add(ruleconditional, position231)
+						add(ruleconditional, position256)
 					}
 				}
-			l213:
-				add(rulearg, position212)
+			l238:
+				add(rulearg, position237)
 			}
 			return true
-		l211:
-			position, tokenIndex = position211, tokenIndex211
+		l236:
+			position, tokenIndex = position236, tokenIndex236
 			return false
 		},
-		/* 5 COND <- <(('>' '<' Action26) / ('<' '=' Action27) / ('>' '=' Action28) / ('=' '=' Action29) / ('!' '=' Action30) / ('<' Action31) / ('>' Action32))> */
+		/* 5 COND <- <(('>' '<' Action28) / ('<' '=' Action29) / ('>' '=' Action30) / ('=' '=' Action31) / ('!' '=' Action32) / ('<' Action33) / ('>' Action34))> */
 		nil,
-		/* 6 conditional <- <(Action33 condint condLT condfield condLT condint Action34)> */
+		/* 6 conditional <- <(Action35 condint condLT condfield condLT condint Action36)> */
 		nil,
-		/* 7 condint <- <(<decimal> sp Action35)> */
+		/* 7 condint <- <(<decimal> sp Action37)> */
 		func() bool {
-			position239, tokenIndex239 := position, tokenIndex
+			position264, tokenIndex264 := position, tokenIndex
 			{
-				position240 := position
+				position265 := position
 				{
-					position241 := position
+					position266 := position
 					if !_rules[ruledecimal]() {
-						goto l239
+						goto l264
 					}
-					add(rulePegText, position241)
+					add(rulePegText, position266)
 				}
 				if !_rules[rulesp]() {
-					goto l239
+					goto l264
 				}
 				{
-					add(ruleAction35, position)
+					add(ruleAction37, position)
 				}
-				add(rulecondint, position240)
+				add(rulecondint, position265)
 			}
 			return true
-		l239:
-			position, tokenIndex = position239, tokenIndex239
+		l264:
+			position, tokenIndex = position264, tokenIndex264
 			return false
 		},
-		/* 8 condLT <- <(<(('<' '=') / '<')> sp Action36)> */
+		/* 8 condLT <- <(<(('<' '=') / '<')> sp Action38)> */
 		func() bool {
-			position243, tokenIndex243 := position, tokenIndex
+			position268, tokenIndex268 := position, tokenIndex
 			{
-				position244 := position
+				position269 := position
 				{
-					position245 := position
+					position270 := position
 					{
-						position246, tokenIndex246 := position, tokenIndex
+						position271, tokenIndex271 := position, tokenIndex
 						if buffer[position] != rune('<') {
-							goto l247
+							goto l272
 						}
 						position++
 						if buffer[position] != rune('=') {
-							goto l247
+							goto l272
 						}
 						position++
-						goto l246
-					l247:
-						position, tokenIndex = position246, tokenIndex246
+						goto l271
+					l272:
+						position, tokenIndex = position271, tokenIndex271
 						if buffer[position] != rune('<') {
-							goto l243
+							goto l268
 						}
 						position++
 					}
-				l246:
-					add(rulePegText, position245)
+				l271:
+					add(rulePegText, position270)
 				}
 				if !_rules[rulesp]() {
-					goto l243
+					goto l268
 				}
 				{
-					add(ruleAction36, position)
+					add(ruleAction38, position)
 				}
-				add(rulecondLT, position244)
+				add(rulecondLT, position269)
 			}
 			return true
-		l243:
-			position, tokenIndex = position243, tokenIndex243
+		l268:
+			position, tokenIndex = position268, tokenIndex268
 			return false
 		},
-		/* 9 condfield <- <(<fieldExpr> sp Action37)> */
+		/* 9 condfield <- <(<fieldExpr> sp Action39)> */
 		nil,
-		/* 10 value <- <(item / (lbrack Action38 items rbrack Action39))> */
+		/* 10 value <- <(item / (lbrack Action40 items rbrack Action41))> */
 		func() bool {
-			position250, tokenIndex250 := position, tokenIndex
+			position275, tokenIndex275 := position, tokenIndex
 			{
-				position251 := position
+				position276 := position
 				{
-					position252, tokenIndex252 := position, tokenIndex
+					position277, tokenIndex277 := position, tokenIndex
 					if !_rules[ruleitem]() {
-						goto l253
+						goto l278
 					}
-					goto l252
-				l253:
-					position, tokenIndex = position252, tokenIndex252
+					goto l277
+				l278:
+					position, tokenIndex = position277, tokenIndex277
 					{
-						position254 := position
+						position279 := position
 						if buffer[position] != rune('[') {
-							goto l250
+							goto l275
 						}
 						position++
 						if !_rules[rulesp]() {
-							goto l250
+							goto l275
 						}
-						add(rulelbrack, position254)
-					}
-					{
-						add(ruleAction38, position)
-					}
-					if !_rules[ruleitems]() {
-						goto l250
-					}
-					{
-						position256 := position
-						if !_rules[rulesp]() {
-							goto l250
-						}
-						if buffer[position] != rune(']') {
-							goto l250
-						}
-						position++
-						if !_rules[rulesp]() {
-							goto l250
-						}
-						add(rulerbrack, position256)
-					}
-					{
-						add(ruleAction39, position)
-					}
-				}
-			l252:
-				add(rulevalue, position251)
-			}
-			return true
-		l250:
-			position, tokenIndex = position250, tokenIndex250
-			return false
-		},
-		/* 11 items <- <(item (comma items)?)> */
-		func() bool {
-			position258, tokenIndex258 := position, tokenIndex
-			{
-				position259 := position
-				if !_rules[ruleitem]() {
-					goto l258
-				}
-				{
-					position260, tokenIndex260 := position, tokenIndex
-					if !_rules[rulecomma]() {
-						goto l260
-					}
-					if !_rules[ruleitems]() {
-						goto l260
-					}
-					goto l261
-				l260:
-					position, tokenIndex = position260, tokenIndex260
-				}
-			l261:
-				add(ruleitems, position259)
-			}
-			return true
-		l258:
-			position, tokenIndex = position258, tokenIndex258
-			return false
-		},
-		/* 12 item <- <(('n' 'u' 'l' 'l' &(comma / close) Action40) / ('t' 'r' 'u' 'e' &(comma / close) Action41) / ('f' 'a' 'l' 's' 'e' &(comma / close) Action42) / (timestampfmt Action43) / (<decimal> Action44) / (<IDENT> Action45 open allargs comma? close Action46) / (<([a-z] / [A-Z] / [0-9] / '-' / '_' / ':')+> Action47) / (<('"' doublequotedstring '"')> Action48) / (<('\'' singlequotedstring '\'')> Action49))> */
-		func() bool {
-			position262, tokenIndex262 := position, tokenIndex
-			{
-				position263 := position
-				{
-					position264, tokenIndex264 := position, tokenIndex
-					if buffer[position] != rune('n') {
-						goto l265
-					}
-					position++
-					if buffer[position] != rune('u') {
-						goto l265
-					}
-					position++
-					if buffer[position] != rune('l') {
-						goto l265
-					}
-					position++
-					if buffer[position] != rune('l') {
-						goto l265
-					}
-					position++
-					{
-						position266, tokenIndex266 := position, tokenIndex
-						{
-							position267, tokenIndex267 := position, tokenIndex
-							if !_rules[rulecomma]() {
-								goto l268
-							}
-							goto l267
-						l268:
-							position, tokenIndex = position267, tokenIndex267
-							if !_rules[ruleclose]() {
-								goto l265
-							}
-						}
-					l267:
-						position, tokenIndex = position266, tokenIndex266
+						add(rulelbrack, position279)
 					}
 					{
 						add(ruleAction40, position)
 					}
-					goto l264
-				l265:
-					position, tokenIndex = position264, tokenIndex264
-					if buffer[position] != rune('t') {
-						goto l270
+					if !_rules[ruleitems]() {
+						goto l275
 					}
-					position++
-					if buffer[position] != rune('r') {
-						goto l270
-					}
-					position++
-					if buffer[position] != rune('u') {
-						goto l270
-					}
-					position++
-					if buffer[position] != rune('e') {
-						goto l270
-					}
-					position++
 					{
-						position271, tokenIndex271 := position, tokenIndex
-						{
-							position272, tokenIndex272 := position, tokenIndex
-							if !_rules[rulecomma]() {
-								goto l273
-							}
-							goto l272
-						l273:
-							position, tokenIndex = position272, tokenIndex272
-							if !_rules[ruleclose]() {
-								goto l270
-							}
+						position281 := position
+						if !_rules[rulesp]() {
+							goto l275
 						}
-					l272:
-						position, tokenIndex = position271, tokenIndex271
+						if buffer[position] != rune(']') {
+							goto l275
+						}
+						position++
+						if !_rules[rulesp]() {
+							goto l275
+						}
+						add(rulerbrack, position281)
 					}
 					{
 						add(ruleAction41, position)
 					}
-					goto l264
-				l270:
-					position, tokenIndex = position264, tokenIndex264
-					if buffer[position] != rune('f') {
-						goto l275
+				}
+			l277:
+				add(rulevalue, position276)
+			}
+			return true
+		l275:
+			position, tokenIndex = position275, tokenIndex275
+			return false
+		},
+		/* 11 items <- <(item (comma items)?)> */
+		func() bool {
+			position283, tokenIndex283 := position, tokenIndex
+			{
+				position284 := position
+				if !_rules[ruleitem]() {
+					goto l283
+				}
+				{
+					position285, tokenIndex285 := position, tokenIndex
+					if !_rules[rulecomma]() {
+						goto l285
+					}
+					if !_rules[ruleitems]() {
+						goto l285
+					}
+					goto l286
+				l285:
+					position, tokenIndex = position285, tokenIndex285
+				}
+			l286:
+				add(ruleitems, position284)
+			}
+			return true
+		l283:
+			position, tokenIndex = position283, tokenIndex283
+			return false
+		},
+		/* 12 item <- <(('n' 'u' 'l' 'l' &(comma / close) Action42) / ('t' 'r' 'u' 'e' &(comma / close) Action43) / ('f' 'a' 'l' 's' 'e' &(comma / close) Action44) / (timestampfmt Action45) / (<decimal> Action46) / (<IDENT> Action47 open allargs comma? close Action48) / (<([a-z] / [A-Z] / [0-9] / '-' / '_' / ':')+> Action49) / (<('"' doublequotedstring '"')> Action50) / (<('\'' singlequotedstring '\'')> Action51))> */
+		func() bool {
+			position287, tokenIndex287 := position, tokenIndex
+			{
+				position288 := position
+				{
+					position289, tokenIndex289 := position, tokenIndex
+					if buffer[position] != rune('n') {
+						goto l290
 					}
 					position++
-					if buffer[position] != rune('a') {
-						goto l275
+					if buffer[position] != rune('u') {
+						goto l290
 					}
 					position++
 					if buffer[position] != rune('l') {
-						goto l275
+						goto l290
 					}
 					position++
-					if buffer[position] != rune('s') {
-						goto l275
-					}
-					position++
-					if buffer[position] != rune('e') {
-						goto l275
+					if buffer[position] != rune('l') {
+						goto l290
 					}
 					position++
 					{
-						position276, tokenIndex276 := position, tokenIndex
+						position291, tokenIndex291 := position, tokenIndex
 						{
-							position277, tokenIndex277 := position, tokenIndex
+							position292, tokenIndex292 := position, tokenIndex
 							if !_rules[rulecomma]() {
-								goto l278
+								goto l293
 							}
-							goto l277
-						l278:
-							position, tokenIndex = position277, tokenIndex277
+							goto l292
+						l293:
+							position, tokenIndex = position292, tokenIndex292
 							if !_rules[ruleclose]() {
-								goto l275
+								goto l290
 							}
 						}
-					l277:
-						position, tokenIndex = position276, tokenIndex276
+					l292:
+						position, tokenIndex = position291, tokenIndex291
 					}
 					{
 						add(ruleAction42, position)
 					}
-					goto l264
-				l275:
-					position, tokenIndex = position264, tokenIndex264
-					if !_rules[ruletimestampfmt]() {
-						goto l280
+					goto l289
+				l290:
+					position, tokenIndex = position289, tokenIndex289
+					if buffer[position] != rune('t') {
+						goto l295
+					}
+					position++
+					if buffer[position] != rune('r') {
+						goto l295
+					}
+					position++
+					if buffer[position] != rune('u') {
+						goto l295
+					}
+					position++
+					if buffer[position] != rune('e') {
+						goto l295
+					}
+					position++
+					{
+						position296, tokenIndex296 := position, tokenIndex
+						{
+							position297, tokenIndex297 := position, tokenIndex
+							if !_rules[rulecomma]() {
+								goto l298
+							}
+							goto l297
+						l298:
+							position, tokenIndex = position297, tokenIndex297
+							if !_rules[ruleclose]() {
+								goto l295
+							}
+						}
+					l297:
+						position, tokenIndex = position296, tokenIndex296
 					}
 					{
 						add(ruleAction43, position)
 					}
-					goto l264
-				l280:
-					position, tokenIndex = position264, tokenIndex264
+					goto l289
+				l295:
+					position, tokenIndex = position289, tokenIndex289
+					if buffer[position] != rune('f') {
+						goto l300
+					}
+					position++
+					if buffer[position] != rune('a') {
+						goto l300
+					}
+					position++
+					if buffer[position] != rune('l') {
+						goto l300
+					}
+					position++
+					if buffer[position] != rune('s') {
+						goto l300
+					}
+					position++
+					if buffer[position] != rune('e') {
+						goto l300
+					}
+					position++
 					{
-						position283 := position
-						if !_rules[ruledecimal]() {
-							goto l282
+						position301, tokenIndex301 := position, tokenIndex
+						{
+							position302, tokenIndex302 := position, tokenIndex
+							if !_rules[rulecomma]() {
+								goto l303
+							}
+							goto l302
+						l303:
+							position, tokenIndex = position302, tokenIndex302
+							if !_rules[ruleclose]() {
+								goto l300
+							}
 						}
-						add(rulePegText, position283)
+					l302:
+						position, tokenIndex = position301, tokenIndex301
 					}
 					{
 						add(ruleAction44, position)
 					}
-					goto l264
-				l282:
-					position, tokenIndex = position264, tokenIndex264
-					{
-						position286 := position
-						if !_rules[ruleIDENT]() {
-							goto l285
-						}
-						add(rulePegText, position286)
+					goto l289
+				l300:
+					position, tokenIndex = position289, tokenIndex289
+					if !_rules[ruletimestampfmt]() {
+						goto l305
 					}
 					{
 						add(ruleAction45, position)
 					}
-					if !_rules[ruleopen]() {
-						goto l285
-					}
-					if !_rules[ruleallargs]() {
-						goto l285
-					}
+					goto l289
+				l305:
+					position, tokenIndex = position289, tokenIndex289
 					{
-						position288, tokenIndex288 := position, tokenIndex
-						if !_rules[rulecomma]() {
-							goto l288
+						position308 := position
+						if !_rules[ruledecimal]() {
+							goto l307
 						}
-						goto l289
-					l288:
-						position, tokenIndex = position288, tokenIndex288
-					}
-				l289:
-					if !_rules[ruleclose]() {
-						goto l285
+						add(rulePegText, position308)
 					}
 					{
 						add(ruleAction46, position)
 					}
-					goto l264
-				l285:
-					position, tokenIndex = position264, tokenIndex264
+					goto l289
+				l307:
+					position, tokenIndex = position289, tokenIndex289
 					{
-						position292 := position
-						{
-							position295, tokenIndex295 := position, tokenIndex
-							if c := buffer[position]; c < rune('a') || c > rune('z') {
-								goto l296
-							}
-							position++
-							goto l295
-						l296:
-							position, tokenIndex = position295, tokenIndex295
-							if c := buffer[position]; c < rune('A') || c > rune('Z') {
-								goto l297
-							}
-							position++
-							goto l295
-						l297:
-							position, tokenIndex = position295, tokenIndex295
-							if c := buffer[position]; c < rune('0') || c > rune('9') {
-								goto l298
-							}
-							position++
-							goto l295
-						l298:
-							position, tokenIndex = position295, tokenIndex295
-							if buffer[position] != rune('-') {
-								goto l299
-							}
-							position++
-							goto l295
-						l299:
-							position, tokenIndex = position295, tokenIndex295
-							if buffer[position] != rune('_') {
-								goto l300
-							}
-							position++
-							goto l295
-						l300:
-							position, tokenIndex = position295, tokenIndex295
-							if buffer[position] != rune(':') {
-								goto l291
-							}
-							position++
+						position311 := position
+						if !_rules[ruleIDENT]() {
+							goto l310
 						}
-					l295:
-					l293:
-						{
-							position294, tokenIndex294 := position, tokenIndex
-							{
-								position301, tokenIndex301 := position, tokenIndex
-								if c := buffer[position]; c < rune('a') || c > rune('z') {
-									goto l302
-								}
-								position++
-								goto l301
-							l302:
-								position, tokenIndex = position301, tokenIndex301
-								if c := buffer[position]; c < rune('A') || c > rune('Z') {
-									goto l303
-								}
-								position++
-								goto l301
-							l303:
-								position, tokenIndex = position301, tokenIndex301
-								if c := buffer[position]; c < rune('0') || c > rune('9') {
-									goto l304
-								}
-								position++
-								goto l301
-							l304:
-								position, tokenIndex = position301, tokenIndex301
-								if buffer[position] != rune('-') {
-									goto l305
-								}
-								position++
-								goto l301
-							l305:
-								position, tokenIndex = position301, tokenIndex301
-								if buffer[position] != rune('_') {
-									goto l306
-								}
-								position++
-								goto l301
-							l306:
-								position, tokenIndex = position301, tokenIndex301
-								if buffer[position] != rune(':') {
-									goto l294
-								}
-								position++
-							}
-						l301:
-							goto l293
-						l294:
-							position, tokenIndex = position294, tokenIndex294
-						}
-						add(rulePegText, position292)
+						add(rulePegText, position311)
 					}
 					{
 						add(ruleAction47, position)
 					}
-					goto l264
-				l291:
-					position, tokenIndex = position264, tokenIndex264
+					if !_rules[ruleopen]() {
+						goto l310
+					}
+					if !_rules[ruleallargs]() {
+						goto l310
+					}
 					{
-						position309 := position
-						if buffer[position] != rune('"') {
-							goto l308
+						position313, tokenIndex313 := position, tokenIndex
+						if !_rules[rulecomma]() {
+							goto l313
 						}
-						position++
-						if !_rules[ruledoublequotedstring]() {
-							goto l308
-						}
-						if buffer[position] != rune('"') {
-							goto l308
-						}
-						position++
-						add(rulePegText, position309)
+						goto l314
+					l313:
+						position, tokenIndex = position313, tokenIndex313
+					}
+				l314:
+					if !_rules[ruleclose]() {
+						goto l310
 					}
 					{
 						add(ruleAction48, position)
 					}
-					goto l264
-				l308:
-					position, tokenIndex = position264, tokenIndex264
+					goto l289
+				l310:
+					position, tokenIndex = position289, tokenIndex289
 					{
-						position311 := position
-						if buffer[position] != rune('\'') {
-							goto l262
+						position317 := position
+						{
+							position320, tokenIndex320 := position, tokenIndex
+							if c := buffer[position]; c < rune('a') || c > rune('z') {
+								goto l321
+							}
+							position++
+							goto l320
+						l321:
+							position, tokenIndex = position320, tokenIndex320
+							if c := buffer[position]; c < rune('A') || c > rune('Z') {
+								goto l322
+							}
+							position++
+							goto l320
+						l322:
+							position, tokenIndex = position320, tokenIndex320
+							if c := buffer[position]; c < rune('0') || c > rune('9') {
+								goto l323
+							}
+							position++
+							goto l320
+						l323:
+							position, tokenIndex = position320, tokenIndex320
+							if buffer[position] != rune('-') {
+								goto l324
+							}
+							position++
+							goto l320
+						l324:
+							position, tokenIndex = position320, tokenIndex320
+							if buffer[position] != rune('_') {
+								goto l325
+							}
+							position++
+							goto l320
+						l325:
+							position, tokenIndex = position320, tokenIndex320
+							if buffer[position] != rune(':') {
+								goto l316
+							}
+							position++
 						}
-						position++
-						if !_rules[rulesinglequotedstring]() {
-							goto l262
+					l320:
+					l318:
+						{
+							position319, tokenIndex319 := position, tokenIndex
+							{
+								position326, tokenIndex326 := position, tokenIndex
+								if c := buffer[position]; c < rune('a') || c > rune('z') {
+									goto l327
+								}
+								position++
+								goto l326
+							l327:
+								position, tokenIndex = position326, tokenIndex326
+								if c := buffer[position]; c < rune('A') || c > rune('Z') {
+									goto l328
+								}
+								position++
+								goto l326
+							l328:
+								position, tokenIndex = position326, tokenIndex326
+								if c := buffer[position]; c < rune('0') || c > rune('9') {
+									goto l329
+								}
+								position++
+								goto l326
+							l329:
+								position, tokenIndex = position326, tokenIndex326
+								if buffer[position] != rune('-') {
+									goto l330
+								}
+								position++
+								goto l326
+							l330:
+								position, tokenIndex = position326, tokenIndex326
+								if buffer[position] != rune('_') {
+									goto l331
+								}
+								position++
+								goto l326
+							l331:
+								position, tokenIndex = position326, tokenIndex326
+								if buffer[position] != rune(':') {
+									goto l319
+								}
+								position++
+							}
+						l326:
+							goto l318
+						l319:
+							position, tokenIndex = position319, tokenIndex319
 						}
-						if buffer[position] != rune('\'') {
-							goto l262
-						}
-						position++
-						add(rulePegText, position311)
+						add(rulePegText, position317)
 					}
 					{
 						add(ruleAction49, position)
 					}
+					goto l289
+				l316:
+					position, tokenIndex = position289, tokenIndex289
+					{
+						position334 := position
+						if buffer[position] != rune('"') {
+							goto l333
+						}
+						position++
+						if !_rules[ruledoublequotedstring]() {
+							goto l333
+						}
+						if buffer[position] != rune('"') {
+							goto l333
+						}
+						position++
+						add(rulePegText, position334)
+					}
+					{
+						add(ruleAction50, position)
+					}
+					goto l289
+				l333:
+					position, tokenIndex = position289, tokenIndex289
+					{
+						position336 := position
+						if buffer[position] != rune('\'') {
+							goto l287
+						}
+						position++
+						if !_rules[rulesinglequotedstring]() {
+							goto l287
+						}
+						if buffer[position] != rune('\'') {
+							goto l287
+						}
+						position++
+						add(rulePegText, position336)
+					}
+					{
+						add(ruleAction51, position)
+					}
 				}
-			l264:
-				add(ruleitem, position263)
+			l289:
+				add(ruleitem, position288)
 			}
 			return true
-		l262:
-			position, tokenIndex = position262, tokenIndex262
+		l287:
+			position, tokenIndex = position287, tokenIndex287
 			return false
 		},
 		/* 13 doublequotedstring <- <(('\\' '"') / ('\\' '\\') / ('\\' 'n') / ('\\' 't') / (!('"' / '\\') .))*> */
 		func() bool {
 			{
-				position314 := position
-			l315:
+				position339 := position
+			l340:
 				{
-					position316, tokenIndex316 := position, tokenIndex
+					position341, tokenIndex341 := position, tokenIndex
 					{
-						position317, tokenIndex317 := position, tokenIndex
+						position342, tokenIndex342 := position, tokenIndex
 						if buffer[position] != rune('\\') {
-							goto l318
+							goto l343
 						}
 						position++
 						if buffer[position] != rune('"') {
-							goto l318
+							goto l343
 						}
 						position++
-						goto l317
-					l318:
-						position, tokenIndex = position317, tokenIndex317
+						goto l342
+					l343:
+						position, tokenIndex = position342, tokenIndex342
 						if buffer[position] != rune('\\') {
-							goto l319
+							goto l344
 						}
 						position++
 						if buffer[position] != rune('\\') {
-							goto l319
+							goto l344
 						}
 						position++
-						goto l317
-					l319:
-						position, tokenIndex = position317, tokenIndex317
+						goto l342
+					l344:
+						position, tokenIndex = position342, tokenIndex342
 						if buffer[position] != rune('\\') {
-							goto l320
+							goto l345
 						}
 						position++
 						if buffer[position] != rune('n') {
-							goto l320
+							goto l345
 						}
 						position++
-						goto l317
-					l320:
-						position, tokenIndex = position317, tokenIndex317
+						goto l342
+					l345:
+						position, tokenIndex = position342, tokenIndex342
 						if buffer[position] != rune('\\') {
-							goto l321
+							goto l346
 						}
 						position++
 						if buffer[position] != rune('t') {
-							goto l321
+							goto l346
 						}
 						position++
-						goto l317
-					l321:
-						position, tokenIndex = position317, tokenIndex317
+						goto l342
+					l346:
+						position, tokenIndex = position342, tokenIndex342
 						{
-							position322, tokenIndex322 := position, tokenIndex
+							position347, tokenIndex347 := position, tokenIndex
 							{
-								position323, tokenIndex323 := position, tokenIndex
+								position348, tokenIndex348 := position, tokenIndex
 								if buffer[position] != rune('"') {
-									goto l324
+									goto l349
 								}
 								position++
-								goto l323
-							l324:
-								position, tokenIndex = position323, tokenIndex323
+								goto l348
+							l349:
+								position, tokenIndex = position348, tokenIndex348
 								if buffer[position] != rune('\\') {
-									goto l322
+									goto l347
 								}
 								position++
 							}
-						l323:
-							goto l316
-						l322:
-							position, tokenIndex = position322, tokenIndex322
+						l348:
+							goto l341
+						l347:
+							position, tokenIndex = position347, tokenIndex347
 						}
 						if !matchDot() {
-							goto l316
+							goto l341
 						}
 					}
-				l317:
-					goto l315
-				l316:
-					position, tokenIndex = position316, tokenIndex316
+				l342:
+					goto l340
+				l341:
+					position, tokenIndex = position341, tokenIndex341
 				}
-				add(ruledoublequotedstring, position314)
+				add(ruledoublequotedstring, position339)
 			}
 			return true
 		},
 		/* 14 singlequotedstring <- <(('\\' '\'') / ('\\' '\\') / ('\\' 'n') / ('\\' 't') / (!('\'' / '\\') .))*> */
 		func() bool {
 			{
-				position326 := position
-			l327:
+				position351 := position
+			l352:
 				{
-					position328, tokenIndex328 := position, tokenIndex
+					position353, tokenIndex353 := position, tokenIndex
 					{
-						position329, tokenIndex329 := position, tokenIndex
+						position354, tokenIndex354 := position, tokenIndex
 						if buffer[position] != rune('\\') {
-							goto l330
+							goto l355
 						}
 						position++
 						if buffer[position] != rune('\'') {
-							goto l330
+							goto l355
 						}
 						position++
-						goto l329
-					l330:
-						position, tokenIndex = position329, tokenIndex329
+						goto l354
+					l355:
+						position, tokenIndex = position354, tokenIndex354
 						if buffer[position] != rune('\\') {
-							goto l331
+							goto l356
 						}
 						position++
 						if buffer[position] != rune('\\') {
-							goto l331
+							goto l356
 						}
 						position++
-						goto l329
-					l331:
-						position, tokenIndex = position329, tokenIndex329
+						goto l354
+					l356:
+						position, tokenIndex = position354, tokenIndex354
 						if buffer[position] != rune('\\') {
-							goto l332
+							goto l357
 						}
 						position++
 						if buffer[position] != rune('n') {
-							goto l332
+							goto l357
 						}
 						position++
-						goto l329
-					l332:
-						position, tokenIndex = position329, tokenIndex329
+						goto l354
+					l357:
+						position, tokenIndex = position354, tokenIndex354
 						if buffer[position] != rune('\\') {
-							goto l333
+							goto l358
 						}
 						position++
 						if buffer[position] != rune('t') {
-							goto l333
+							goto l358
 						}
 						position++
-						goto l329
-					l333:
-						position, tokenIndex = position329, tokenIndex329
+						goto l354
+					l358:
+						position, tokenIndex = position354, tokenIndex354
 						{
-							position334, tokenIndex334 := position, tokenIndex
+							position359, tokenIndex359 := position, tokenIndex
 							{
-								position335, tokenIndex335 := position, tokenIndex
+								position360, tokenIndex360 := position, tokenIndex
 								if buffer[position] != rune('\'') {
-									goto l336
+									goto l361
 								}
 								position++
-								goto l335
-							l336:
-								position, tokenIndex = position335, tokenIndex335
+								goto l360
+							l361:
+								position, tokenIndex = position360, tokenIndex360
 								if buffer[position] != rune('\\') {
-									goto l334
+									goto l359
 								}
 								position++
 							}
-						l335:
-							goto l328
-						l334:
-							position, tokenIndex = position334, tokenIndex334
+						l360:
+							goto l353
+						l359:
+							position, tokenIndex = position359, tokenIndex359
 						}
 						if !matchDot() {
-							goto l328
+							goto l353
 						}
 					}
-				l329:
-					goto l327
-				l328:
-					position, tokenIndex = position328, tokenIndex328
+				l354:
+					goto l352
+				l353:
+					position, tokenIndex = position353, tokenIndex353
 				}
-				add(rulesinglequotedstring, position326)
+				add(rulesinglequotedstring, position351)
 			}
 			return true
 		},
 		/* 15 fieldExpr <- <(([a-z] / [A-Z] / '_') ([a-z] / [A-Z] / [0-9] / '_' / '-')*)> */
 		func() bool {
-			position337, tokenIndex337 := position, tokenIndex
+			position362, tokenIndex362 := position, tokenIndex
 			{
-				position338 := position
+				position363 := position
 				{
-					position339, tokenIndex339 := position, tokenIndex
+					position364, tokenIndex364 := position, tokenIndex
 					if c := buffer[position]; c < rune('a') || c > rune('z') {
-						goto l340
+						goto l365
 					}
 					position++
-					goto l339
-				l340:
-					position, tokenIndex = position339, tokenIndex339
+					goto l364
+				l365:
+					position, tokenIndex = position364, tokenIndex364
 					if c := buffer[position]; c < rune('A') || c > rune('Z') {
-						goto l341
+						goto l366
 					}
 					position++
-					goto l339
-				l341:
-					position, tokenIndex = position339, tokenIndex339
+					goto l364
+				l366:
+					position, tokenIndex = position364, tokenIndex364
 					if buffer[position] != rune('_') {
-						goto l337
+						goto l362
 					}
 					position++
 				}
-			l339:
-			l342:
+			l364:
+			l367:
 				{
-					position343, tokenIndex343 := position, tokenIndex
+					position368, tokenIndex368 := position, tokenIndex
 					{
-						position344, tokenIndex344 := position, tokenIndex
+						position369, tokenIndex369 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l345
+							goto l370
 						}
 						position++
-						goto l344
-					l345:
-						position, tokenIndex = position344, tokenIndex344
+						goto l369
+					l370:
+						position, tokenIndex = position369, tokenIndex369
 						if c := buffer[position]; c < rune('A') || c > rune('Z') {
-							goto l346
+							goto l371
 						}
 						position++
-						goto l344
-					l346:
-						position, tokenIndex = position344, tokenIndex344
+						goto l369
+					l371:
+						position, tokenIndex = position369, tokenIndex369
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l347
+							goto l372
 						}
 						position++
-						goto l344
-					l347:
-						position, tokenIndex = position344, tokenIndex344
+						goto l369
+					l372:
+						position, tokenIndex = position369, tokenIndex369
 						if buffer[position] != rune('_') {
-							goto l348
+							goto l373
 						}
 						position++
-						goto l344
-					l348:
-						position, tokenIndex = position344, tokenIndex344
+						goto l369
+					l373:
+						position, tokenIndex = position369, tokenIndex369
 						if buffer[position] != rune('-') {
-							goto l343
+							goto l368
 						}
 						position++
 					}
-				l344:
-					goto l342
-				l343:
-					position, tokenIndex = position343, tokenIndex343
+				l369:
+					goto l367
+				l368:
+					position, tokenIndex = position368, tokenIndex368
 				}
-				add(rulefieldExpr, position338)
+				add(rulefieldExpr, position363)
 			}
 			return true
-		l337:
-			position, tokenIndex = position337, tokenIndex337
+		l362:
+			position, tokenIndex = position362, tokenIndex362
 			return false
 		},
-		/* 16 field <- <(<(fieldExpr / reserved)> Action50)> */
+		/* 16 field <- <(<(fieldExpr / reserved)> Action52)> */
 		func() bool {
-			position349, tokenIndex349 := position, tokenIndex
+			position374, tokenIndex374 := position, tokenIndex
 			{
-				position350 := position
+				position375 := position
 				{
-					position351 := position
+					position376 := position
 					{
-						position352, tokenIndex352 := position, tokenIndex
+						position377, tokenIndex377 := position, tokenIndex
 						if !_rules[rulefieldExpr]() {
-							goto l353
+							goto l378
 						}
-						goto l352
-					l353:
-						position, tokenIndex = position352, tokenIndex352
+						goto l377
+					l378:
+						position, tokenIndex = position377, tokenIndex377
 						{
-							position354 := position
+							position379 := position
 							{
-								position355, tokenIndex355 := position, tokenIndex
+								position380, tokenIndex380 := position, tokenIndex
 								if buffer[position] != rune('_') {
-									goto l356
+									goto l381
 								}
 								position++
 								if buffer[position] != rune('r') {
-									goto l356
+									goto l381
 								}
 								position++
 								if buffer[position] != rune('o') {
-									goto l356
+									goto l381
 								}
 								position++
 								if buffer[position] != rune('w') {
-									goto l356
+									goto l381
 								}
 								position++
-								goto l355
-							l356:
-								position, tokenIndex = position355, tokenIndex355
+								goto l380
+							l381:
+								position, tokenIndex = position380, tokenIndex380
 								if buffer[position] != rune('_') {
-									goto l357
+									goto l382
 								}
 								position++
 								if buffer[position] != rune('c') {
-									goto l357
+									goto l382
 								}
 								position++
 								if buffer[position] != rune('o') {
-									goto l357
+									goto l382
 								}
 								position++
 								if buffer[position] != rune('l') {
-									goto l357
+									goto l382
 								}
 								position++
-								goto l355
-							l357:
-								position, tokenIndex = position355, tokenIndex355
+								goto l380
+							l382:
+								position, tokenIndex = position380, tokenIndex380
 								if buffer[position] != rune('_') {
-									goto l358
+									goto l383
 								}
 								position++
 								if buffer[position] != rune('s') {
-									goto l358
+									goto l383
 								}
 								position++
 								if buffer[position] != rune('t') {
-									goto l358
+									goto l383
 								}
 								position++
 								if buffer[position] != rune('a') {
-									goto l358
+									goto l383
 								}
 								position++
 								if buffer[position] != rune('r') {
-									goto l358
+									goto l383
 								}
 								position++
 								if buffer[position] != rune('t') {
-									goto l358
+									goto l383
 								}
 								position++
-								goto l355
-							l358:
-								position, tokenIndex = position355, tokenIndex355
+								goto l380
+							l383:
+								position, tokenIndex = position380, tokenIndex380
 								if buffer[position] != rune('_') {
-									goto l359
+									goto l384
 								}
 								position++
 								if buffer[position] != rune('e') {
-									goto l359
+									goto l384
 								}
 								position++
 								if buffer[position] != rune('n') {
-									goto l359
+									goto l384
 								}
 								position++
 								if buffer[position] != rune('d') {
-									goto l359
+									goto l384
 								}
 								position++
-								goto l355
-							l359:
-								position, tokenIndex = position355, tokenIndex355
+								goto l380
+							l384:
+								position, tokenIndex = position380, tokenIndex380
 								if buffer[position] != rune('_') {
-									goto l360
+									goto l385
 								}
 								position++
 								if buffer[position] != rune('t') {
-									goto l360
+									goto l385
 								}
 								position++
 								if buffer[position] != rune('i') {
-									goto l360
+									goto l385
 								}
 								position++
 								if buffer[position] != rune('m') {
-									goto l360
+									goto l385
 								}
 								position++
 								if buffer[position] != rune('e') {
-									goto l360
+									goto l385
 								}
 								position++
 								if buffer[position] != rune('s') {
-									goto l360
+									goto l385
 								}
 								position++
 								if buffer[position] != rune('t') {
-									goto l360
+									goto l385
 								}
 								position++
 								if buffer[position] != rune('a') {
-									goto l360
+									goto l385
 								}
 								position++
 								if buffer[position] != rune('m') {
-									goto l360
+									goto l385
 								}
 								position++
 								if buffer[position] != rune('p') {
-									goto l360
+									goto l385
 								}
 								position++
-								goto l355
-							l360:
-								position, tokenIndex = position355, tokenIndex355
+								goto l380
+							l385:
+								position, tokenIndex = position380, tokenIndex380
 								if buffer[position] != rune('_') {
-									goto l349
+									goto l374
 								}
 								position++
 								if buffer[position] != rune('f') {
-									goto l349
+									goto l374
 								}
 								position++
 								if buffer[position] != rune('i') {
-									goto l349
+									goto l374
 								}
 								position++
 								if buffer[position] != rune('e') {
-									goto l349
+									goto l374
 								}
 								position++
 								if buffer[position] != rune('l') {
-									goto l349
+									goto l374
 								}
 								position++
 								if buffer[position] != rune('d') {
-									goto l349
+									goto l374
 								}
 								position++
 							}
-						l355:
-							add(rulereserved, position354)
+						l380:
+							add(rulereserved, position379)
 						}
 					}
-				l352:
-					add(rulePegText, position351)
+				l377:
+					add(rulePegText, position376)
 				}
 				{
-					add(ruleAction50, position)
+					add(ruleAction52, position)
 				}
-				add(rulefield, position350)
+				add(rulefield, position375)
 			}
 			return true
-		l349:
-			position, tokenIndex = position349, tokenIndex349
+		l374:
+			position, tokenIndex = position374, tokenIndex374
 			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> Action51)> */
+		/* 18 posfield <- <(<fieldExpr> Action53)> */
 		func() bool {
-			position363, tokenIndex363 := position, tokenIndex
+			position388, tokenIndex388 := position, tokenIndex
 			{
-				position364 := position
+				position389 := position
 				{
-					position365 := position
+					position390 := position
 					if !_rules[rulefieldExpr]() {
-						goto l363
+						goto l388
 					}
-					add(rulePegText, position365)
+					add(rulePegText, position390)
 				}
 				{
-					add(ruleAction51, position)
+					add(ruleAction53, position)
 				}
-				add(ruleposfield, position364)
+				add(ruleposfield, position389)
 			}
 			return true
-		l363:
-			position, tokenIndex = position363, tokenIndex363
+		l388:
+			position, tokenIndex = position388, tokenIndex388
 			return false
 		},
-		/* 19 col <- <((<digits> Action52) / (<('\'' singlequotedstring '\'')> Action53) / (<('"' doublequotedstring '"')> Action54))> */
+		/* 19 col <- <((<digits> Action54) / (<('\'' singlequotedstring '\'')> Action55) / (<('"' doublequotedstring '"')> Action56))> */
 		func() bool {
-			position367, tokenIndex367 := position, tokenIndex
+			position392, tokenIndex392 := position, tokenIndex
 			{
-				position368 := position
+				position393 := position
 				{
-					position369, tokenIndex369 := position, tokenIndex
+					position394, tokenIndex394 := position, tokenIndex
 					{
-						position371 := position
+						position396 := position
 						if !_rules[ruledigits]() {
-							goto l370
+							goto l395
 						}
-						add(rulePegText, position371)
-					}
-					{
-						add(ruleAction52, position)
-					}
-					goto l369
-				l370:
-					position, tokenIndex = position369, tokenIndex369
-					{
-						position374 := position
-						if buffer[position] != rune('\'') {
-							goto l373
-						}
-						position++
-						if !_rules[rulesinglequotedstring]() {
-							goto l373
-						}
-						if buffer[position] != rune('\'') {
-							goto l373
-						}
-						position++
-						add(rulePegText, position374)
-					}
-					{
-						add(ruleAction53, position)
-					}
-					goto l369
-				l373:
-					position, tokenIndex = position369, tokenIndex369
-					{
-						position376 := position
-						if buffer[position] != rune('"') {
-							goto l367
-						}
-						position++
-						if !_rules[ruledoublequotedstring]() {
-							goto l367
-						}
-						if buffer[position] != rune('"') {
-							goto l367
-						}
-						position++
-						add(rulePegText, position376)
+						add(rulePegText, position396)
 					}
 					{
 						add(ruleAction54, position)
 					}
+					goto l394
+				l395:
+					position, tokenIndex = position394, tokenIndex394
+					{
+						position399 := position
+						if buffer[position] != rune('\'') {
+							goto l398
+						}
+						position++
+						if !_rules[rulesinglequotedstring]() {
+							goto l398
+						}
+						if buffer[position] != rune('\'') {
+							goto l398
+						}
+						position++
+						add(rulePegText, position399)
+					}
+					{
+						add(ruleAction55, position)
+					}
+					goto l394
+				l398:
+					position, tokenIndex = position394, tokenIndex394
+					{
+						position401 := position
+						if buffer[position] != rune('"') {
+							goto l392
+						}
+						position++
+						if !_rules[ruledoublequotedstring]() {
+							goto l392
+						}
+						if buffer[position] != rune('"') {
+							goto l392
+						}
+						position++
+						add(rulePegText, position401)
+					}
+					{
+						add(ruleAction56, position)
+					}
 				}
-			l369:
-				add(rulecol, position368)
+			l394:
+				add(rulecol, position393)
 			}
 			return true
-		l367:
-			position, tokenIndex = position367, tokenIndex367
+		l392:
+			position, tokenIndex = position392, tokenIndex392
 			return false
 		},
-		/* 20 row <- <((<digits> Action55) / (<('\'' singlequotedstring '\'')> Action56) / (<('"' doublequotedstring '"')> Action57))> */
+		/* 20 row <- <((<digits> Action57) / (<('\'' singlequotedstring '\'')> Action58) / (<('"' doublequotedstring '"')> Action59))> */
 		nil,
 		/* 21 open <- <('(' sp)> */
 		func() bool {
-			position379, tokenIndex379 := position, tokenIndex
+			position404, tokenIndex404 := position, tokenIndex
 			{
-				position380 := position
+				position405 := position
 				if buffer[position] != rune('(') {
-					goto l379
+					goto l404
 				}
 				position++
 				if !_rules[rulesp]() {
-					goto l379
+					goto l404
 				}
-				add(ruleopen, position380)
+				add(ruleopen, position405)
 			}
 			return true
-		l379:
-			position, tokenIndex = position379, tokenIndex379
+		l404:
+			position, tokenIndex = position404, tokenIndex404
 			return false
 		},
 		/* 22 close <- <(sp ')' sp)> */
 		func() bool {
-			position381, tokenIndex381 := position, tokenIndex
+			position406, tokenIndex406 := position, tokenIndex
 			{
-				position382 := position
+				position407 := position
 				if !_rules[rulesp]() {
-					goto l381
+					goto l406
 				}
 				if buffer[position] != rune(')') {
-					goto l381
+					goto l406
 				}
 				position++
 				if !_rules[rulesp]() {
-					goto l381
+					goto l406
 				}
-				add(ruleclose, position382)
+				add(ruleclose, position407)
 			}
 			return true
-		l381:
-			position, tokenIndex = position381, tokenIndex381
+		l406:
+			position, tokenIndex = position406, tokenIndex406
 			return false
 		},
 		/* 23 sp <- <(' ' / '\t' / '\n')*> */
 		func() bool {
 			{
-				position384 := position
-			l385:
+				position409 := position
+			l410:
 				{
-					position386, tokenIndex386 := position, tokenIndex
+					position411, tokenIndex411 := position, tokenIndex
 					{
-						position387, tokenIndex387 := position, tokenIndex
+						position412, tokenIndex412 := position, tokenIndex
 						if buffer[position] != rune(' ') {
-							goto l388
+							goto l413
 						}
 						position++
-						goto l387
-					l388:
-						position, tokenIndex = position387, tokenIndex387
+						goto l412
+					l413:
+						position, tokenIndex = position412, tokenIndex412
 						if buffer[position] != rune('\t') {
-							goto l389
+							goto l414
 						}
 						position++
-						goto l387
-					l389:
-						position, tokenIndex = position387, tokenIndex387
+						goto l412
+					l414:
+						position, tokenIndex = position412, tokenIndex412
 						if buffer[position] != rune('\n') {
-							goto l386
+							goto l411
 						}
 						position++
 					}
-				l387:
-					goto l385
-				l386:
-					position, tokenIndex = position386, tokenIndex386
+				l412:
+					goto l410
+				l411:
+					position, tokenIndex = position411, tokenIndex411
 				}
-				add(rulesp, position384)
+				add(rulesp, position409)
 			}
 			return true
 		},
 		/* 24 eq <- <(sp '=' sp)> */
 		func() bool {
-			position390, tokenIndex390 := position, tokenIndex
+			position415, tokenIndex415 := position, tokenIndex
 			{
-				position391 := position
+				position416 := position
 				if !_rules[rulesp]() {
-					goto l390
+					goto l415
 				}
 				if buffer[position] != rune('=') {
-					goto l390
+					goto l415
 				}
 				position++
 				if !_rules[rulesp]() {
-					goto l390
+					goto l415
 				}
-				add(ruleeq, position391)
+				add(ruleeq, position416)
 			}
 			return true
-		l390:
-			position, tokenIndex = position390, tokenIndex390
+		l415:
+			position, tokenIndex = position415, tokenIndex415
 			return false
 		},
 		/* 25 comma <- <(sp ',' sp)> */
 		func() bool {
-			position392, tokenIndex392 := position, tokenIndex
+			position417, tokenIndex417 := position, tokenIndex
 			{
-				position393 := position
+				position418 := position
 				if !_rules[rulesp]() {
-					goto l392
+					goto l417
 				}
 				if buffer[position] != rune(',') {
-					goto l392
+					goto l417
 				}
 				position++
 				if !_rules[rulesp]() {
-					goto l392
+					goto l417
 				}
-				add(rulecomma, position393)
+				add(rulecomma, position418)
 			}
 			return true
-		l392:
-			position, tokenIndex = position392, tokenIndex392
+		l417:
+			position, tokenIndex = position417, tokenIndex417
 			return false
 		},
 		/* 26 lbrack <- <('[' sp)> */
@@ -3497,312 +3686,312 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 		nil,
 		/* 28 IDENT <- <(([a-z] / [A-Z]) ([a-z] / [A-Z] / [0-9])*)> */
 		func() bool {
-			position396, tokenIndex396 := position, tokenIndex
+			position421, tokenIndex421 := position, tokenIndex
 			{
-				position397 := position
+				position422 := position
 				{
-					position398, tokenIndex398 := position, tokenIndex
+					position423, tokenIndex423 := position, tokenIndex
 					if c := buffer[position]; c < rune('a') || c > rune('z') {
-						goto l399
+						goto l424
 					}
 					position++
-					goto l398
-				l399:
-					position, tokenIndex = position398, tokenIndex398
+					goto l423
+				l424:
+					position, tokenIndex = position423, tokenIndex423
 					if c := buffer[position]; c < rune('A') || c > rune('Z') {
-						goto l396
+						goto l421
 					}
 					position++
 				}
-			l398:
-			l400:
+			l423:
+			l425:
 				{
-					position401, tokenIndex401 := position, tokenIndex
+					position426, tokenIndex426 := position, tokenIndex
 					{
-						position402, tokenIndex402 := position, tokenIndex
+						position427, tokenIndex427 := position, tokenIndex
 						if c := buffer[position]; c < rune('a') || c > rune('z') {
-							goto l403
+							goto l428
 						}
 						position++
-						goto l402
-					l403:
-						position, tokenIndex = position402, tokenIndex402
+						goto l427
+					l428:
+						position, tokenIndex = position427, tokenIndex427
 						if c := buffer[position]; c < rune('A') || c > rune('Z') {
-							goto l404
+							goto l429
 						}
 						position++
-						goto l402
-					l404:
-						position, tokenIndex = position402, tokenIndex402
+						goto l427
+					l429:
+						position, tokenIndex = position427, tokenIndex427
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l401
+							goto l426
 						}
 						position++
 					}
-				l402:
-					goto l400
-				l401:
-					position, tokenIndex = position401, tokenIndex401
+				l427:
+					goto l425
+				l426:
+					position, tokenIndex = position426, tokenIndex426
 				}
-				add(ruleIDENT, position397)
+				add(ruleIDENT, position422)
 			}
 			return true
-		l396:
-			position, tokenIndex = position396, tokenIndex396
+		l421:
+			position, tokenIndex = position421, tokenIndex421
 			return false
 		},
 		/* 29 digits <- <[0-9]+> */
 		func() bool {
-			position405, tokenIndex405 := position, tokenIndex
+			position430, tokenIndex430 := position, tokenIndex
 			{
-				position406 := position
+				position431 := position
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l405
+					goto l430
 				}
 				position++
-			l407:
+			l432:
 				{
-					position408, tokenIndex408 := position, tokenIndex
+					position433, tokenIndex433 := position, tokenIndex
 					if c := buffer[position]; c < rune('0') || c > rune('9') {
-						goto l408
+						goto l433
 					}
 					position++
-					goto l407
-				l408:
-					position, tokenIndex = position408, tokenIndex408
+					goto l432
+				l433:
+					position, tokenIndex = position433, tokenIndex433
 				}
-				add(ruledigits, position406)
+				add(ruledigits, position431)
 			}
 			return true
-		l405:
-			position, tokenIndex = position405, tokenIndex405
+		l430:
+			position, tokenIndex = position430, tokenIndex430
 			return false
 		},
 		/* 30 signedDigits <- <('-'? digits)> */
 		nil,
 		/* 31 decimal <- <((signedDigits ('.' digits?)?) / ('-'? '.' digits))> */
 		func() bool {
-			position410, tokenIndex410 := position, tokenIndex
+			position435, tokenIndex435 := position, tokenIndex
 			{
-				position411 := position
+				position436 := position
 				{
-					position412, tokenIndex412 := position, tokenIndex
+					position437, tokenIndex437 := position, tokenIndex
 					{
-						position414 := position
+						position439 := position
 						{
-							position415, tokenIndex415 := position, tokenIndex
+							position440, tokenIndex440 := position, tokenIndex
 							if buffer[position] != rune('-') {
-								goto l415
+								goto l440
 							}
 							position++
-							goto l416
-						l415:
-							position, tokenIndex = position415, tokenIndex415
+							goto l441
+						l440:
+							position, tokenIndex = position440, tokenIndex440
 						}
-					l416:
+					l441:
 						if !_rules[ruledigits]() {
-							goto l413
+							goto l438
 						}
-						add(rulesignedDigits, position414)
+						add(rulesignedDigits, position439)
 					}
 					{
-						position417, tokenIndex417 := position, tokenIndex
+						position442, tokenIndex442 := position, tokenIndex
 						if buffer[position] != rune('.') {
-							goto l417
+							goto l442
 						}
 						position++
 						{
-							position419, tokenIndex419 := position, tokenIndex
+							position444, tokenIndex444 := position, tokenIndex
 							if !_rules[ruledigits]() {
-								goto l419
+								goto l444
 							}
-							goto l420
-						l419:
-							position, tokenIndex = position419, tokenIndex419
+							goto l445
+						l444:
+							position, tokenIndex = position444, tokenIndex444
 						}
-					l420:
-						goto l418
-					l417:
-						position, tokenIndex = position417, tokenIndex417
+					l445:
+						goto l443
+					l442:
+						position, tokenIndex = position442, tokenIndex442
 					}
-				l418:
-					goto l412
-				l413:
-					position, tokenIndex = position412, tokenIndex412
+				l443:
+					goto l437
+				l438:
+					position, tokenIndex = position437, tokenIndex437
 					{
-						position421, tokenIndex421 := position, tokenIndex
+						position446, tokenIndex446 := position, tokenIndex
 						if buffer[position] != rune('-') {
-							goto l421
+							goto l446
 						}
 						position++
-						goto l422
-					l421:
-						position, tokenIndex = position421, tokenIndex421
+						goto l447
+					l446:
+						position, tokenIndex = position446, tokenIndex446
 					}
-				l422:
+				l447:
 					if buffer[position] != rune('.') {
-						goto l410
+						goto l435
 					}
 					position++
 					if !_rules[ruledigits]() {
-						goto l410
+						goto l435
 					}
 				}
-			l412:
-				add(ruledecimal, position411)
+			l437:
+				add(ruledecimal, position436)
 			}
 			return true
-		l410:
-			position, tokenIndex = position410, tokenIndex410
+		l435:
+			position, tokenIndex = position435, tokenIndex435
 			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 {
-			position423, tokenIndex423 := position, tokenIndex
+			position448, tokenIndex448 := position, tokenIndex
 			{
-				position424 := position
+				position449 := position
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l423
+					goto l448
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l423
+					goto l448
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l423
+					goto l448
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l423
+					goto l448
 				}
 				position++
 				if buffer[position] != rune('-') {
-					goto l423
+					goto l448
 				}
 				position++
 				{
-					position425, tokenIndex425 := position, tokenIndex
+					position450, tokenIndex450 := position, tokenIndex
 					if buffer[position] != rune('0') {
-						goto l426
+						goto l451
 					}
 					position++
-					goto l425
-				l426:
-					position, tokenIndex = position425, tokenIndex425
+					goto l450
+				l451:
+					position, tokenIndex = position450, tokenIndex450
 					if buffer[position] != rune('1') {
-						goto l423
+						goto l448
 					}
 					position++
 				}
-			l425:
+			l450:
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l423
+					goto l448
 				}
 				position++
 				if buffer[position] != rune('-') {
-					goto l423
+					goto l448
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('3') {
-					goto l423
+					goto l448
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l423
+					goto l448
 				}
 				position++
 				if buffer[position] != rune('T') {
-					goto l423
+					goto l448
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l423
+					goto l448
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l423
+					goto l448
 				}
 				position++
 				if buffer[position] != rune(':') {
-					goto l423
+					goto l448
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l423
+					goto l448
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l423
+					goto l448
 				}
 				position++
-				add(ruletimestampbasicfmt, position424)
+				add(ruletimestampbasicfmt, position449)
 			}
 			return true
-		l423:
-			position, tokenIndex = position423, tokenIndex423
+		l448:
+			position, tokenIndex = position448, tokenIndex448
 			return false
 		},
 		/* 33 timestampfmt <- <(('"' <timestampbasicfmt> '"') / ('\'' <timestampbasicfmt> '\'') / <timestampbasicfmt>)> */
 		func() bool {
-			position427, tokenIndex427 := position, tokenIndex
+			position452, tokenIndex452 := position, tokenIndex
 			{
-				position428 := position
+				position453 := position
 				{
-					position429, tokenIndex429 := position, tokenIndex
+					position454, tokenIndex454 := position, tokenIndex
 					if buffer[position] != rune('"') {
-						goto l430
+						goto l455
 					}
 					position++
 					{
-						position431 := position
+						position456 := position
 						if !_rules[ruletimestampbasicfmt]() {
-							goto l430
+							goto l455
 						}
-						add(rulePegText, position431)
+						add(rulePegText, position456)
 					}
 					if buffer[position] != rune('"') {
-						goto l430
+						goto l455
 					}
 					position++
-					goto l429
-				l430:
-					position, tokenIndex = position429, tokenIndex429
+					goto l454
+				l455:
+					position, tokenIndex = position454, tokenIndex454
 					if buffer[position] != rune('\'') {
-						goto l432
+						goto l457
 					}
 					position++
 					{
-						position433 := position
+						position458 := position
 						if !_rules[ruletimestampbasicfmt]() {
-							goto l432
+							goto l457
 						}
-						add(rulePegText, position433)
+						add(rulePegText, position458)
 					}
 					if buffer[position] != rune('\'') {
-						goto l432
+						goto l457
 					}
 					position++
-					goto l429
-				l432:
-					position, tokenIndex = position429, tokenIndex429
+					goto l454
+				l457:
+					position, tokenIndex = position454, tokenIndex454
 					{
-						position434 := position
+						position459 := position
 						if !_rules[ruletimestampbasicfmt]() {
-							goto l427
+							goto l452
 						}
-						add(rulePegText, position434)
+						add(rulePegText, position459)
 					}
 				}
-			l429:
-				add(ruletimestampfmt, position428)
+			l454:
+				add(ruletimestampfmt, position453)
 			}
 			return true
-		l427:
-			position, tokenIndex = position427, tokenIndex427
+		l452:
+			position, tokenIndex = position452, tokenIndex452
 			return false
 		},
-		/* 34 timestamp <- <(<timestampfmt> Action58)> */
+		/* 34 timestamp <- <(<timestampfmt> Action60)> */
 		nil,
 		/* 36 Action0 <- <{p.startCall("Set")}> */
 		nil,
@@ -3836,92 +4025,96 @@ func (p *PQL) Init(options ...func(*PQL) error) error {
 		nil,
 		/* 51 Action15 <- <{p.endCall()}> */
 		nil,
-		/* 52 Action16 <- <{p.startCall("Rows")}> */
+		/* 52 Action16 <- <{p.startCall("Percentile")}> */
 		nil,
 		/* 53 Action17 <- <{p.endCall()}> */
 		nil,
-		/* 54 Action18 <- <{p.startCall("Range")}> */
+		/* 54 Action18 <- <{p.startCall("Rows")}> */
 		nil,
-		/* 55 Action19 <- <{p.addField("from")}> */
+		/* 55 Action19 <- <{p.endCall()}> */
 		nil,
-		/* 56 Action20 <- <{p.addVal(text)}> */
+		/* 56 Action20 <- <{p.startCall("Range")}> */
 		nil,
-		/* 57 Action21 <- <{p.addField("to")}> */
+		/* 57 Action21 <- <{p.addField("from")}> */
 		nil,
 		/* 58 Action22 <- <{p.addVal(text)}> */
 		nil,
-		/* 59 Action23 <- <{p.endCall()}> */
+		/* 59 Action23 <- <{p.addField("to")}> */
+		nil,
+		/* 60 Action24 <- <{p.addVal(text)}> */
+		nil,
+		/* 61 Action25 <- <{p.endCall()}> */
 		nil,
 		nil,
-		/* 61 Action24 <- <{ p.startCall(text) }> */
+		/* 63 Action26 <- <{ p.startCall(text) }> */
 		nil,
-		/* 62 Action25 <- <{ p.endCall() }> */
+		/* 64 Action27 <- <{ p.endCall() }> */
 		nil,
-		/* 63 Action26 <- <{ p.addBTWN() }> */
+		/* 65 Action28 <- <{ p.addBTWN() }> */
 		nil,
-		/* 64 Action27 <- <{ p.addLTE() }> */
+		/* 66 Action29 <- <{ p.addLTE() }> */
 		nil,
-		/* 65 Action28 <- <{ p.addGTE() }> */
+		/* 67 Action30 <- <{ p.addGTE() }> */
 		nil,
-		/* 66 Action29 <- <{ p.addEQ() }> */
+		/* 68 Action31 <- <{ p.addEQ() }> */
 		nil,
-		/* 67 Action30 <- <{ p.addNEQ() }> */
+		/* 69 Action32 <- <{ p.addNEQ() }> */
 		nil,
-		/* 68 Action31 <- <{ p.addLT() }> */
+		/* 70 Action33 <- <{ p.addLT() }> */
 		nil,
-		/* 69 Action32 <- <{ p.addGT() }> */
+		/* 71 Action34 <- <{ p.addGT() }> */
 		nil,
-		/* 70 Action33 <- <{p.startConditional()}> */
+		/* 72 Action35 <- <{p.startConditional()}> */
 		nil,
-		/* 71 Action34 <- <{p.endConditional()}> */
-		nil,
-		/* 72 Action35 <- <{p.condAdd(text)}> */
-		nil,
-		/* 73 Action36 <- <{p.condAdd(text)}> */
+		/* 73 Action36 <- <{p.endConditional()}> */
 		nil,
 		/* 74 Action37 <- <{p.condAdd(text)}> */
 		nil,
-		/* 75 Action38 <- <{ p.startList() }> */
+		/* 75 Action38 <- <{p.condAdd(text)}> */
 		nil,
-		/* 76 Action39 <- <{ p.endList() }> */
+		/* 76 Action39 <- <{p.condAdd(text)}> */
 		nil,
-		/* 77 Action40 <- <{ p.addVal(nil) }> */
+		/* 77 Action40 <- <{ p.startList() }> */
 		nil,
-		/* 78 Action41 <- <{ p.addVal(true) }> */
+		/* 78 Action41 <- <{ p.endList() }> */
 		nil,
-		/* 79 Action42 <- <{ p.addVal(false) }> */
+		/* 79 Action42 <- <{ p.addVal(nil) }> */
 		nil,
-		/* 80 Action43 <- <{ p.addVal(text) }> */
+		/* 80 Action43 <- <{ p.addVal(true) }> */
 		nil,
-		/* 81 Action44 <- <{ p.addNumVal(text) }> */
+		/* 81 Action44 <- <{ p.addVal(false) }> */
 		nil,
-		/* 82 Action45 <- <{ p.startCall(text) }> */
+		/* 82 Action45 <- <{ p.addVal(text) }> */
 		nil,
-		/* 83 Action46 <- <{ p.addVal(p.endCall()) }> */
+		/* 83 Action46 <- <{ p.addNumVal(text) }> */
 		nil,
-		/* 84 Action47 <- <{ p.addVal(text) }> */
+		/* 84 Action47 <- <{ p.startCall(text) }> */
 		nil,
-		/* 85 Action48 <- <{ p.addVal(text) }> */
+		/* 85 Action48 <- <{ p.addVal(p.endCall()) }> */
 		nil,
 		/* 86 Action49 <- <{ p.addVal(text) }> */
 		nil,
-		/* 87 Action50 <- <{ p.addField(text) }> */
+		/* 87 Action50 <- <{ p.addVal(text) }> */
 		nil,
-		/* 88 Action51 <- <{ p.addPosStr("_field", text) }> */
+		/* 88 Action51 <- <{ p.addVal(text) }> */
 		nil,
-		/* 89 Action52 <- <{p.addPosNum("_col", text)}> */
+		/* 89 Action52 <- <{ p.addField(text) }> */
 		nil,
-		/* 90 Action53 <- <{p.addPosStr("_col", text)}> */
+		/* 90 Action53 <- <{ p.addPosStr("_field", text) }> */
 		nil,
-		/* 91 Action54 <- <{p.addPosStr("_col", text)}> */
+		/* 91 Action54 <- <{p.addPosNum("_col", text)}> */
 		nil,
-		/* 92 Action55 <- <{p.addPosNum("_row", text)}> */
+		/* 92 Action55 <- <{p.addPosStr("_col", text)}> */
 		nil,
-		/* 93 Action56 <- <{p.addPosStr("_row", text)}> */
+		/* 93 Action56 <- <{p.addPosStr("_col", text)}> */
 		nil,
-		/* 94 Action57 <- <{p.addPosStr("_row", text)}> */
+		/* 94 Action57 <- <{p.addPosNum("_row", text)}> */
 		nil,
-		/* 95 Action58 <- <{p.addPosStr("_timestamp", text)}> */
+		/* 95 Action58 <- <{p.addPosStr("_row", text)}> */
+		nil,
+		/* 96 Action59 <- <{p.addPosStr("_row", text)}> */
+		nil,
+		/* 97 Action60 <- <{p.addPosStr("_timestamp", text)}> */
 		nil,
 	}
 	p.rules = _rules