From 02498ce57a153b3b33dc53f0e7f4995056ea1e44 Mon Sep 17 00:00:00 2001 From: Nia Weiss Date: Fri, 13 Nov 2020 18:00:38 -0500 Subject: [PATCH] add TopK with perpendicular BSI bitmaps --- bsi.go | 120 ++ encoding/proto/proto.go | 31 + executor.go | 129 ++ executor_test.go | 31 + fragment.go | 41 +- internal/public.pb.go | 701 ++++++---- internal/public.proto | 5 + pql/ast.go | 9 + pql/pql.peg | 1 + pql/pql.peg.go | 2808 ++++++++++++++++++++------------------- 10 files changed, 2295 insertions(+), 1581 deletions(-) create mode 100644 bsi.go diff --git a/bsi.go b/bsi.go new file mode 100644 index 000000000..c8956e21e --- /dev/null +++ b/bsi.go @@ -0,0 +1,120 @@ +// Copyright 2020 Pilosa Corp. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package pilosa + +import "math/bits" + +// bsiData contains BSI-structured data. +type bsiData []*Row + +// insert a value for a column in the BSI data. +func (bsi *bsiData) insert(column uint64, value uint64) { + data := *bsi + for value != 0 { + bit := bits.TrailingZeros64(value) + value &^= 1 << bit + + for len(data) <= bit { + data = append(data, NewRow()) + } + + data[bit].SetBit(column) + } + *bsi = data +} + +// pivotDescending loops over nonzero BSI values in descending order. +// For each value, the provided function is called with the value and a slice of the associated columns. +func (bsi bsiData) pivotDescending(filter *Row, branch uint64, limit, offset *uint64, fn func(uint64, ...uint64)) { + // This "pivot" algorithm works by treating the BSI data as a tree. + // Each branch of this tree corresponds to a power-of-2-sized range of BSI values. + // Each range is subdivided into 2 ranges of half size, which form lower branches. + // Eventually, a range of width 1 cannot be subdivided and forms a leaf. + // At each branch and leaf, there is a bitmap of all columns within the corresponding range. + // The lower branches are formed as a difference or intersect of the upper branch's bitmap with the BSI bit that subdivides the range. + // This function uses a depth-first search over this virtual tree. + + switch { + case !filter.Any(): + // There are no remaining data. + + case offset != nil && *offset >= filter.Count(): + // Skip this entire branch. + *offset -= filter.Count() + + case limit != nil && *limit == 0: + // The limit has been reached. + // No more data is necessary. + + case len(bsi) == 0: + // This is a leaf node. + cols := filter.Columns() + if offset != nil { + cols = cols[*offset:] + *offset = 0 + } + if limit != nil { + if *limit < uint64(len(cols)) { + cols = cols[:*limit] + } + *limit -= uint64(len(cols)) + } + fn(branch, cols...) + + default: + // Pivot over the highest bit. + upperBranch, lowerBranch := branch|(1< len(y) { + x, y = y, x + } + carry := NewRow() + out := make(bsiData, 0, len(y)) + for i, v := range x { + out = append(out, v.Xor(y[i]).Xor(carry)) + carry = v.Intersect(y[i]).Union(v.Intersect(carry), y[i].Intersect(carry)) + } + for _, v := range y[len(x):] { + out = append(out, v.Xor(carry)) + carry = v.Intersect(carry) + } + if carry.Any() { + out = append(out, carry) + } + return out +} diff --git a/encoding/proto/proto.go b/encoding/proto/proto.go index b2c368751..1631e47dd 100644 --- a/encoding/proto/proto.go +++ b/encoding/proto/proto.go @@ -312,6 +312,14 @@ func (s Serializer) Unmarshal(buf []byte, m pilosa.Message) error { } s.decodeAtomicRecord(msg, mt) return nil + case *[]*pilosa.Row: + msg := &internal.RowMatrix{} + err := proto.Unmarshal(buf, msg) + if err != nil { + return errors.Wrap(err, "unmarshaling RowMatrix") + } + *mt = s.decodeRowMatrix(msg) + return nil default: panic(fmt.Sprintf("unhandled pilosa.Message of type %T: %#v", mt, m)) } @@ -542,6 +550,9 @@ func (s Serializer) encodeQueryResponse(m *pilosa.QueryResponse) *internal.Query case pilosa.PairField: pb.Results[i].Type = queryResultTypePairField pb.Results[i].PairField = s.encodePairField(result) + case []*pilosa.Row: + pb.Results[i].Type = queryResultTypeRowMatrix + pb.Results[i].RowMatrix = s.encodeRowMatrix(result) case nil: pb.Results[i].Type = queryResultTypeNil default: @@ -900,6 +911,15 @@ func (s Serializer) encodeAtomicRecord(msg *pilosa.AtomicRecord) *internal.Atomi return ar } +func (s Serializer) encodeRowMatrix(msg []*pilosa.Row) *internal.RowMatrix { + rows := make([]*internal.Row, len(msg)) + for i, r := range msg { + rows[i] = s.encodeRow(r) + } + + return &internal.RowMatrix{Rows: rows} +} + func (s Serializer) encodeTransaction(trns *pilosa.Transaction) *internal.Transaction { if trns == nil { return nil @@ -1341,6 +1361,14 @@ func (s Serializer) decodeAtomicRecord(pb *internal.AtomicRecord, m *pilosa.Atom } } +func (s Serializer) decodeRowMatrix(pb *internal.RowMatrix) []*pilosa.Row { + rows := make([]*pilosa.Row, len(pb.Rows)) + for i, r := range pb.Rows { + rows[i] = s.decodeRow(r) + } + return rows +} + func decodeTransaction(pb *internal.Transaction, trns *pilosa.Transaction) { trns.ID = pb.ID trns.Active = pb.Active @@ -1364,6 +1392,7 @@ const ( queryResultTypeRowIdentifiers queryResultTypePair queryResultTypePairField + queryResultTypeRowMatrix queryResultTypeSignedRow queryResultTypeExtractedIDMatrix queryResultTypeExtractedTable @@ -1401,6 +1430,8 @@ func (s Serializer) decodeQueryResult(pb *internal.QueryResult) interface{} { return s.decodeExtractedIDMatrix(pb.ExtractedIDMatrix) case queryResultTypeExtractedTable: return s.decodeExtractedTable(pb.ExtractedTable) + case queryResultTypeRowMatrix: + return s.decodeRowMatrix(pb.RowMatrix) } panic(fmt.Sprintf("unknown type: %d", pb.Type)) } diff --git a/executor.go b/executor.go index 97c750e74..505897fed 100644 --- a/executor.go +++ b/executor.go @@ -324,6 +324,12 @@ func (e *executor) safeCopy(resp QueryResponse) (out QueryResponse) { // so does not contain bitmap material, and // should not need to be cloned. out.Results = append(out.Results, x) + case []*Row: + safe := make([]*Row, len(x)) + for i, v := range x { + safe[i] = v.Clone() + } + out.Results = append(out.Results, safe) default: panic(fmt.Sprintf("handle %T here", v)) } @@ -703,6 +709,9 @@ func (e *executor) executeCall(ctx context.Context, qcx *Qcx, index string, c *p case "SetColumnAttrs": statFn() return nil, e.executeSetColumnAttrs(ctx, qcx, index, c, opt) + case "TopK": + statFn() + return e.executeTopK(ctx, qcx, index, c, shards, opt) case "TopN": statFn() return e.executeTopN(ctx, qcx, index, c, shards, opt) @@ -1808,6 +1817,126 @@ func (e *executor) executeMaxRowShard(ctx context.Context, qcx *Qcx, index strin }, nil } +func (e *executor) executeTopK(ctx context.Context, qcx *Qcx, index string, c *pql.Call, shards []uint64, opt *execOptions) (interface{}, error) { + span, ctx := tracing.StartSpanFromContext(ctx, "Executor.executeTopK") + defer span.Finish() + + mapFn := func(ctx context.Context, shard uint64) (_ interface{}, err error) { + return e.executeTopKShard(ctx, qcx, index, c, shard) + } + + reduceFn := func(ctx context.Context, prev, v interface{}) interface{} { + x, _ := prev.([]*Row) + y, _ := v.([]*Row) + return ([]*Row)(addBSI(x, y)) + } + + other, err := e.mapReduce(ctx, index, shards, c, opt, mapFn, reduceFn) + if err != nil { + return nil, err + } + results, _ := other.([]*Row) + + if opt.Remote { + return results, nil + } + + k, hasK, err := c.UintArg("k") + if err != nil { + return nil, errors.Wrap(err, "fetching k") + } + + var limit *uint64 + if hasK { + limit = &k + } + + var dst []Pair + bsiData(results).pivotDescending(NewRow().Union(results...), 0, limit, nil, func(count uint64, ids ...uint64) { + for _, id := range ids { + dst = append(dst, Pair{ + ID: id, + Count: count, + }) + } + }) + + fieldName, hasFieldName, err := c.StringArg("_field") + if err != nil { + return nil, errors.Wrap(err, "fetching TopK field") + } else if !hasFieldName { + return nil, errors.New("missing field in TopK") + } + + return &PairsField{ + Pairs: dst, + Field: fieldName, + }, nil +} + +func (e *executor) executeTopKShard(ctx context.Context, qcx *Qcx, index string, c *pql.Call, shard uint64) (_ []*Row, err0 error) { + span, ctx := tracing.StartSpanFromContext(ctx, "Executor.executeTopKShard") + defer span.Finish() + + // Look up the index. + idx := e.Holder.Index(index) + if idx == nil { + return nil, ErrIndexNotFound + } + + // Look up the field. + fieldName, hasFieldName, err := c.StringArg("_field") + if err != nil { + return nil, errors.Wrap(err, "fetching TopK field") + } else if !hasFieldName { + return nil, errors.New("missing field in TopK") + } + f := idx.Field(fieldName) + if f == nil { + return nil, ErrFieldNotFound + } + + // Fetch the filter. + var filterBitmap *Row + if filter, hasFilter, err := c.CallArg("filter"); err != nil { + return nil, err + } else if hasFilter { + filterBitmap, err = e.executeBitmapCallShard(ctx, qcx, index, filter, shard) + if err != nil { + return nil, err + } + if !filterBitmap.Any() { + return []*Row(nil), nil + } + } + + tx, finisher, err := qcx.GetTx(Txo{Write: !writable, Index: idx, Shard: shard}) + if err != nil { + return nil, err + } + defer finisher(&err0) + + ftype := f.Type() + switch ftype { + case FieldTypeSet, FieldTypeTime: + return e.executeTopKShardSet(ctx, tx, filterBitmap, index, fieldName, shard) + default: + return nil, errors.Errorf("field type %q is not yet supported by TopK", ftype) + } +} + +func (e *executor) executeTopKShardSet(ctx context.Context, tx Tx, filter *Row, index, field string, shard uint64) ([]*Row, error) { + span, ctx := tracing.StartSpanFromContext(ctx, "Executor.executeTopKShardSet") + defer span.Finish() + + f := e.Holder.fragment(index, field, viewStandard, shard) + if f == nil { + return nil, nil + } + + return f.cardinalityBSISet(ctx, tx, filter) +} + // executeTopN executes a TopN() call. // This first performs the TopN() to determine the top results and then // requeries to retrieve the full counts for each of the top results. diff --git a/executor_test.go b/executor_test.go index d5d0154d2..9dd3053a1 100644 --- a/executor_test.go +++ b/executor_test.go @@ -1063,6 +1063,37 @@ func TestExecutor_Execute_SetRowAttrs(t *testing.T) { }) } +func TestExecutor_Execute_TopK(t *testing.T) { + c := test.MustRunCluster(t, 2) + defer c.Close() + + // Load some test data into a set field. + c.CreateField(t, "i", pilosa.IndexOptions{TrackExistence: true}, "f") + c.ImportBits(t, "i", "f", [][2]uint64{ + {0, 0}, + {0, 1}, + {0, ShardWidth + 2}, + {10, 2}, + {10, ShardWidth}, + {10, 2 * ShardWidth}, + {10, ShardWidth + 1}, + {20, ShardWidth}, + }) + + // Execute query. + if result, err := c.GetNode(0).API.Query(context.Background(), &pilosa.QueryRequest{Index: "i", Query: `TopK(f, k=2)`}); err != nil { + t.Fatal(err) + } else if !reflect.DeepEqual(result.Results, []interface{}{&pilosa.PairsField{ + Pairs: []pilosa.Pair{ + {ID: 10, Count: 4}, + {ID: 0, Count: 3}, + }, + Field: "f", + }}) { + t.Fatalf("unexpected result: %s", spew.Sdump(result)) + } +} + // Ensure a TopN() query can be executed. func TestExecutor_Execute_TopN(t *testing.T) { t.Run("RowIDColumnID", func(t *testing.T) { diff --git a/fragment.go b/fragment.go index 790b98d7a..f7af84160 100644 --- a/fragment.go +++ b/fragment.go @@ -1775,6 +1775,36 @@ func (f *fragment) forEachBit(tx Tx, fn func(rowID, columnID uint64) error) erro }) } +// cardinalityBSISet constructs a perpendicular BSI bitmap containing the cardinality of each specified row in a set field. +func (f *fragment) cardinalityBSISet(ctx context.Context, tx Tx, filter *Row) ([]*Row, error) { + f.mu.Lock() + defer f.mu.Unlock() + + // Fetch row IDs. + rowIDs, err := f.unprotectedRows(ctx, tx, 0) + if err != nil { + return nil, err + } + + // Count the bits in each row. + var out bsiData + for _, id := range rowIDs { + row, err := f.unprotectedRow(tx, id) + if err != nil { + return nil, err + } + var count uint64 + if filter != nil { + count = row.intersectionCount(filter) + } else { + count = row.Count() + } + out.insert(id, count) + } + + return out, nil +} + // top returns the top rows from the fragment. // If opt.Src is specified then only rows which intersect src are returned. // If opt.FilterValues exist then the row attribute specified by field is matched. @@ -3100,11 +3130,16 @@ func (f *fragment) unprotectedRows(ctx context.Context, tx Tx, start uint64, fil var lastRow uint64 = math.MaxUint64 // Loop over the existing containers. + var k uint16 for i.Next() { - // caller doesn't need a result anymore. - if err := ctx.Err(); err != nil { - return nil, err + if k == 0 { + if err := ctx.Err(); err != nil { + // caller doesn't need a result anymore. + return nil, err + } } + k++ + key, c := i.Value() // virtual row for the current container diff --git a/internal/public.pb.go b/internal/public.pb.go index 9ac4c188e..b3038896d 100644 --- a/internal/public.pb.go +++ b/internal/public.pb.go @@ -94,6 +94,53 @@ func (m *Row) GetRoaring() []byte { return nil } +type RowMatrix struct { + Rows []*Row `protobuf:"bytes,1,rep,name=Rows,proto3" json:"Rows,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RowMatrix) Reset() { *m = RowMatrix{} } +func (m *RowMatrix) String() string { return proto.CompactTextString(m) } +func (*RowMatrix) ProtoMessage() {} +func (*RowMatrix) Descriptor() ([]byte, []int) { + return fileDescriptor_413a91106d7bcce8, []int{1} +} +func (m *RowMatrix) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RowMatrix) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RowMatrix.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RowMatrix) XXX_Merge(src proto.Message) { + xxx_messageInfo_RowMatrix.Merge(m, src) +} +func (m *RowMatrix) XXX_Size() int { + return m.Size() +} +func (m *RowMatrix) XXX_DiscardUnknown() { + xxx_messageInfo_RowMatrix.DiscardUnknown(m) +} + +var xxx_messageInfo_RowMatrix proto.InternalMessageInfo + +func (m *RowMatrix) GetRows() []*Row { + if m != nil { + return m.Rows + } + return nil +} + type SignedRow struct { Pos *Row `protobuf:"bytes,1,opt,name=Pos,proto3" json:"Pos,omitempty"` Neg *Row `protobuf:"bytes,2,opt,name=Neg,proto3" json:"Neg,omitempty"` @@ -106,7 +153,7 @@ func (m *SignedRow) Reset() { *m = SignedRow{} } func (m *SignedRow) String() string { return proto.CompactTextString(m) } func (*SignedRow) ProtoMessage() {} func (*SignedRow) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{1} + return fileDescriptor_413a91106d7bcce8, []int{2} } func (m *SignedRow) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -161,7 +208,7 @@ func (m *RowIdentifiers) Reset() { *m = RowIdentifiers{} } func (m *RowIdentifiers) String() string { return proto.CompactTextString(m) } func (*RowIdentifiers) ProtoMessage() {} func (*RowIdentifiers) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{2} + return fileDescriptor_413a91106d7bcce8, []int{3} } func (m *RowIdentifiers) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -215,7 +262,7 @@ func (m *IDList) Reset() { *m = IDList{} } func (m *IDList) String() string { return proto.CompactTextString(m) } func (*IDList) ProtoMessage() {} func (*IDList) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{3} + return fileDescriptor_413a91106d7bcce8, []int{4} } func (m *IDList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -263,7 +310,7 @@ func (m *ExtractedIDColumn) Reset() { *m = ExtractedIDColumn{} } func (m *ExtractedIDColumn) String() string { return proto.CompactTextString(m) } func (*ExtractedIDColumn) ProtoMessage() {} func (*ExtractedIDColumn) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{4} + return fileDescriptor_413a91106d7bcce8, []int{5} } func (m *ExtractedIDColumn) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -318,7 +365,7 @@ func (m *ExtractedIDMatrix) Reset() { *m = ExtractedIDMatrix{} } func (m *ExtractedIDMatrix) String() string { return proto.CompactTextString(m) } func (*ExtractedIDMatrix) ProtoMessage() {} func (*ExtractedIDMatrix) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{5} + return fileDescriptor_413a91106d7bcce8, []int{6} } func (m *ExtractedIDMatrix) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -372,7 +419,7 @@ func (m *KeyList) Reset() { *m = KeyList{} } func (m *KeyList) String() string { return proto.CompactTextString(m) } func (*KeyList) ProtoMessage() {} func (*KeyList) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{6} + return fileDescriptor_413a91106d7bcce8, []int{7} } func (m *KeyList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -426,7 +473,7 @@ func (m *ExtractedTableValue) Reset() { *m = ExtractedTableValue{} } func (m *ExtractedTableValue) String() string { return proto.CompactTextString(m) } func (*ExtractedTableValue) ProtoMessage() {} func (*ExtractedTableValue) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{7} + return fileDescriptor_413a91106d7bcce8, []int{8} } func (m *ExtractedTableValue) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -563,7 +610,7 @@ func (m *ExtractedTableColumn) Reset() { *m = ExtractedTableColumn{} } func (m *ExtractedTableColumn) String() string { return proto.CompactTextString(m) } func (*ExtractedTableColumn) ProtoMessage() {} func (*ExtractedTableColumn) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{8} + return fileDescriptor_413a91106d7bcce8, []int{9} } func (m *ExtractedTableColumn) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -656,7 +703,7 @@ func (m *ExtractedTableField) Reset() { *m = ExtractedTableField{} } func (m *ExtractedTableField) String() string { return proto.CompactTextString(m) } func (*ExtractedTableField) ProtoMessage() {} func (*ExtractedTableField) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{9} + return fileDescriptor_413a91106d7bcce8, []int{10} } func (m *ExtractedTableField) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -711,7 +758,7 @@ func (m *ExtractedTable) Reset() { *m = ExtractedTable{} } func (m *ExtractedTable) String() string { return proto.CompactTextString(m) } func (*ExtractedTable) ProtoMessage() {} func (*ExtractedTable) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{10} + return fileDescriptor_413a91106d7bcce8, []int{11} } func (m *ExtractedTable) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -767,7 +814,7 @@ func (m *Pair) Reset() { *m = Pair{} } func (m *Pair) String() string { return proto.CompactTextString(m) } func (*Pair) ProtoMessage() {} func (*Pair) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{11} + return fileDescriptor_413a91106d7bcce8, []int{12} } func (m *Pair) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -829,7 +876,7 @@ func (m *PairField) Reset() { *m = PairField{} } func (m *PairField) String() string { return proto.CompactTextString(m) } func (*PairField) ProtoMessage() {} func (*PairField) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{12} + return fileDescriptor_413a91106d7bcce8, []int{13} } func (m *PairField) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -884,7 +931,7 @@ func (m *PairsField) Reset() { *m = PairsField{} } func (m *PairsField) String() string { return proto.CompactTextString(m) } func (*PairsField) ProtoMessage() {} func (*PairsField) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{13} + return fileDescriptor_413a91106d7bcce8, []int{14} } func (m *PairsField) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -938,7 +985,7 @@ func (m *Int64) Reset() { *m = Int64{} } func (m *Int64) String() string { return proto.CompactTextString(m) } func (*Int64) ProtoMessage() {} func (*Int64) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{14} + return fileDescriptor_413a91106d7bcce8, []int{15} } func (m *Int64) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -988,7 +1035,7 @@ func (m *FieldRow) Reset() { *m = FieldRow{} } func (m *FieldRow) String() string { return proto.CompactTextString(m) } func (*FieldRow) ProtoMessage() {} func (*FieldRow) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{15} + return fileDescriptor_413a91106d7bcce8, []int{16} } func (m *FieldRow) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1058,7 +1105,7 @@ func (m *GroupCount) Reset() { *m = GroupCount{} } func (m *GroupCount) String() string { return proto.CompactTextString(m) } func (*GroupCount) ProtoMessage() {} func (*GroupCount) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{16} + return fileDescriptor_413a91106d7bcce8, []int{17} } func (m *GroupCount) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1122,7 +1169,7 @@ func (m *ValCount) Reset() { *m = ValCount{} } func (m *ValCount) String() string { return proto.CompactTextString(m) } func (*ValCount) ProtoMessage() {} func (*ValCount) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{17} + return fileDescriptor_413a91106d7bcce8, []int{18} } func (m *ValCount) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1191,7 +1238,7 @@ func (m *Decimal) Reset() { *m = Decimal{} } func (m *Decimal) String() string { return proto.CompactTextString(m) } func (*Decimal) ProtoMessage() {} func (*Decimal) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{18} + return fileDescriptor_413a91106d7bcce8, []int{19} } func (m *Decimal) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1247,7 +1294,7 @@ func (m *ColumnAttrSet) Reset() { *m = ColumnAttrSet{} } func (m *ColumnAttrSet) String() string { return proto.CompactTextString(m) } func (*ColumnAttrSet) ProtoMessage() {} func (*ColumnAttrSet) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{19} + return fileDescriptor_413a91106d7bcce8, []int{20} } func (m *ColumnAttrSet) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1313,7 +1360,7 @@ func (m *Attr) Reset() { *m = Attr{} } func (m *Attr) String() string { return proto.CompactTextString(m) } func (*Attr) ProtoMessage() {} func (*Attr) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{20} + return fileDescriptor_413a91106d7bcce8, []int{21} } func (m *Attr) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1395,7 +1442,7 @@ func (m *AttrMap) Reset() { *m = AttrMap{} } func (m *AttrMap) String() string { return proto.CompactTextString(m) } func (*AttrMap) ProtoMessage() {} func (*AttrMap) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{21} + return fileDescriptor_413a91106d7bcce8, []int{22} } func (m *AttrMap) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1448,7 +1495,7 @@ func (m *QueryRequest) Reset() { *m = QueryRequest{} } func (m *QueryRequest) String() string { return proto.CompactTextString(m) } func (*QueryRequest) ProtoMessage() {} func (*QueryRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{22} + return fileDescriptor_413a91106d7bcce8, []int{23} } func (m *QueryRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1539,7 +1586,7 @@ func (m *QueryResponse) Reset() { *m = QueryResponse{} } func (m *QueryResponse) String() string { return proto.CompactTextString(m) } func (*QueryResponse) ProtoMessage() {} func (*QueryResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{23} + return fileDescriptor_413a91106d7bcce8, []int{24} } func (m *QueryResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1604,6 +1651,7 @@ type QueryResult struct { PairField *PairField `protobuf:"bytes,12,opt,name=PairField,proto3" json:"PairField,omitempty"` ExtractedIDMatrix *ExtractedIDMatrix `protobuf:"bytes,13,opt,name=ExtractedIDMatrix,proto3" json:"ExtractedIDMatrix,omitempty"` ExtractedTable *ExtractedTable `protobuf:"bytes,14,opt,name=ExtractedTable,proto3" json:"ExtractedTable,omitempty"` + RowMatrix *RowMatrix `protobuf:"bytes,15,opt,name=RowMatrix,proto3" json:"RowMatrix,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -1613,7 +1661,7 @@ func (m *QueryResult) Reset() { *m = QueryResult{} } func (m *QueryResult) String() string { return proto.CompactTextString(m) } func (*QueryResult) ProtoMessage() {} func (*QueryResult) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{24} + return fileDescriptor_413a91106d7bcce8, []int{25} } func (m *QueryResult) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1740,6 +1788,13 @@ func (m *QueryResult) GetExtractedTable() *ExtractedTable { return nil } +func (m *QueryResult) GetRowMatrix() *RowMatrix { + if m != nil { + return m.RowMatrix + } + return nil +} + type ImportRequest struct { Index string `protobuf:"bytes,1,opt,name=Index,proto3" json:"Index,omitempty"` Field string `protobuf:"bytes,2,opt,name=Field,proto3" json:"Field,omitempty"` @@ -1761,7 +1816,7 @@ func (m *ImportRequest) Reset() { *m = ImportRequest{} } func (m *ImportRequest) String() string { return proto.CompactTextString(m) } func (*ImportRequest) ProtoMessage() {} func (*ImportRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{25} + return fileDescriptor_413a91106d7bcce8, []int{26} } func (m *ImportRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1888,7 +1943,7 @@ func (m *ImportValueRequest) Reset() { *m = ImportValueRequest{} } func (m *ImportValueRequest) String() string { return proto.CompactTextString(m) } func (*ImportValueRequest) ProtoMessage() {} func (*ImportValueRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{26} + return fileDescriptor_413a91106d7bcce8, []int{27} } func (m *ImportValueRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2008,7 +2063,7 @@ func (m *AtomicRecord) Reset() { *m = AtomicRecord{} } func (m *AtomicRecord) String() string { return proto.CompactTextString(m) } func (*AtomicRecord) ProtoMessage() {} func (*AtomicRecord) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{27} + return fileDescriptor_413a91106d7bcce8, []int{28} } func (m *AtomicRecord) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2076,7 +2131,7 @@ func (m *AtomicImportResponse) Reset() { *m = AtomicImportResponse{} } func (m *AtomicImportResponse) String() string { return proto.CompactTextString(m) } func (*AtomicImportResponse) ProtoMessage() {} func (*AtomicImportResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{28} + return fileDescriptor_413a91106d7bcce8, []int{29} } func (m *AtomicImportResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2126,7 +2181,7 @@ func (m *TranslateKeysRequest) Reset() { *m = TranslateKeysRequest{} } func (m *TranslateKeysRequest) String() string { return proto.CompactTextString(m) } func (*TranslateKeysRequest) ProtoMessage() {} func (*TranslateKeysRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{29} + return fileDescriptor_413a91106d7bcce8, []int{30} } func (m *TranslateKeysRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2194,7 +2249,7 @@ func (m *TranslateKeysResponse) Reset() { *m = TranslateKeysResponse{} } func (m *TranslateKeysResponse) String() string { return proto.CompactTextString(m) } func (*TranslateKeysResponse) ProtoMessage() {} func (*TranslateKeysResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{30} + return fileDescriptor_413a91106d7bcce8, []int{31} } func (m *TranslateKeysResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2243,7 +2298,7 @@ func (m *TranslateIDsRequest) Reset() { *m = TranslateIDsRequest{} } func (m *TranslateIDsRequest) String() string { return proto.CompactTextString(m) } func (*TranslateIDsRequest) ProtoMessage() {} func (*TranslateIDsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{31} + return fileDescriptor_413a91106d7bcce8, []int{32} } func (m *TranslateIDsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2304,7 +2359,7 @@ func (m *TranslateIDsResponse) Reset() { *m = TranslateIDsResponse{} } func (m *TranslateIDsResponse) String() string { return proto.CompactTextString(m) } func (*TranslateIDsResponse) ProtoMessage() {} func (*TranslateIDsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{32} + return fileDescriptor_413a91106d7bcce8, []int{33} } func (m *TranslateIDsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2352,7 +2407,7 @@ func (m *ImportRoaringRequestView) Reset() { *m = ImportRoaringRequestVi func (m *ImportRoaringRequestView) String() string { return proto.CompactTextString(m) } func (*ImportRoaringRequestView) ProtoMessage() {} func (*ImportRoaringRequestView) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{33} + return fileDescriptor_413a91106d7bcce8, []int{34} } func (m *ImportRoaringRequestView) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2411,7 +2466,7 @@ func (m *ImportRoaringRequest) Reset() { *m = ImportRoaringRequest{} } func (m *ImportRoaringRequest) String() string { return proto.CompactTextString(m) } func (*ImportRoaringRequest) ProtoMessage() {} func (*ImportRoaringRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{34} + return fileDescriptor_413a91106d7bcce8, []int{35} } func (m *ImportRoaringRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2498,7 +2553,7 @@ func (m *ImportColumnAttrsRequest) Reset() { *m = ImportColumnAttrsReque func (m *ImportColumnAttrsRequest) String() string { return proto.CompactTextString(m) } func (*ImportColumnAttrsRequest) ProtoMessage() {} func (*ImportColumnAttrsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_413a91106d7bcce8, []int{35} + return fileDescriptor_413a91106d7bcce8, []int{36} } func (m *ImportColumnAttrsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2571,6 +2626,7 @@ func (m *ImportColumnAttrsRequest) GetIndexCreatedAt() int64 { func init() { proto.RegisterType((*Row)(nil), "internal.Row") + proto.RegisterType((*RowMatrix)(nil), "internal.RowMatrix") proto.RegisterType((*SignedRow)(nil), "internal.SignedRow") proto.RegisterType((*RowIdentifiers)(nil), "internal.RowIdentifiers") proto.RegisterType((*IDList)(nil), "internal.IDList") @@ -2611,111 +2667,113 @@ func init() { func init() { proto.RegisterFile("public.proto", fileDescriptor_413a91106d7bcce8) } var fileDescriptor_413a91106d7bcce8 = []byte{ - // 1653 bytes of a gzipped FileDescriptorProto + // 1682 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x4f, 0x6f, 0xdb, 0xca, - 0x11, 0x37, 0x45, 0xca, 0x92, 0x46, 0xb2, 0xe3, 0x6c, 0x94, 0x94, 0x48, 0x1d, 0x47, 0x20, 0xdc, - 0x46, 0x2d, 0x0a, 0x07, 0x4e, 0x93, 0x20, 0x97, 0xb6, 0xb1, 0x23, 0xa7, 0x26, 0x52, 0xbb, 0xe9, - 0xca, 0x70, 0x6e, 0x05, 0x68, 0x69, 0xeb, 0x10, 0xa5, 0x44, 0x95, 0xa2, 0x22, 0xfb, 0x52, 0xa0, - 0x9f, 0x21, 0x97, 0x7e, 0x84, 0x7e, 0x8e, 0x5e, 0xda, 0x63, 0x8f, 0x05, 0xde, 0xe5, 0x21, 0xef, - 0x7d, 0x8b, 0x5c, 0x1e, 0x66, 0x96, 0xab, 0x5d, 0x52, 0xb4, 0x63, 0x04, 0xef, 0xb6, 0xf3, 0x67, - 0x67, 0x67, 0x7e, 0x33, 0x3b, 0x3b, 0x24, 0xb4, 0x26, 0xb3, 0xb3, 0x28, 0x1c, 0xec, 0x4c, 0x92, - 0x38, 0x8d, 0x59, 0x3d, 0x1c, 0xa7, 0x22, 0x19, 0x07, 0x91, 0x37, 0x05, 0x9b, 0xc7, 0x73, 0xe6, - 0x42, 0xed, 0x55, 0x1c, 0xcd, 0x46, 0xe3, 0xa9, 0x6b, 0x75, 0xec, 0xae, 0xc3, 0x15, 0xc9, 0x18, - 0x38, 0x6f, 0xc4, 0xe5, 0xd4, 0xb5, 0x3b, 0x76, 0xb7, 0xc1, 0x69, 0xcd, 0xb6, 0xa1, 0xba, 0x97, - 0xa6, 0xc9, 0xd4, 0xad, 0x74, 0xec, 0x6e, 0xf3, 0xc9, 0xfa, 0x8e, 0x32, 0xb7, 0x83, 0x6c, 0x2e, - 0x85, 0x68, 0x93, 0xc7, 0x41, 0x12, 0x8e, 0xcf, 0x5d, 0xa7, 0x63, 0x75, 0x5b, 0x5c, 0x91, 0xde, - 0x11, 0x34, 0xfa, 0xe1, 0xf9, 0x58, 0x0c, 0xf1, 0xe8, 0x87, 0x60, 0xbf, 0x8d, 0xf1, 0x58, 0xab, - 0xdb, 0x7c, 0xb2, 0xa6, 0x4d, 0xf1, 0x78, 0xce, 0x51, 0x82, 0x0a, 0xc7, 0xe2, 0xdc, 0xad, 0x94, - 0x2a, 0x1c, 0x8b, 0x73, 0xef, 0x05, 0xac, 0xf3, 0x78, 0xee, 0x0f, 0xc5, 0x38, 0x0d, 0xff, 0x12, - 0x8a, 0x84, 0x9c, 0xe6, 0xf1, 0x5c, 0xc5, 0x42, 0xeb, 0x45, 0x20, 0x15, 0x1d, 0x88, 0x77, 0x1f, - 0x56, 0xfd, 0xde, 0x1f, 0xc2, 0x69, 0xca, 0x36, 0xc0, 0xf6, 0x7b, 0x6a, 0x03, 0x2e, 0x3d, 0x1f, - 0x6e, 0x1f, 0x5c, 0xa4, 0x49, 0x30, 0x48, 0xc5, 0xd0, 0xef, 0x49, 0x38, 0xd8, 0x3a, 0x54, 0xfc, - 0x1e, 0xf9, 0xea, 0xf0, 0x8a, 0xdf, 0x63, 0xdb, 0xe0, 0x9c, 0x06, 0x91, 0x02, 0x62, 0x43, 0x3b, - 0x27, 0xcd, 0x72, 0x92, 0x7a, 0x67, 0x39, 0x53, 0x47, 0x41, 0x9a, 0x84, 0x17, 0xec, 0x1e, 0xac, - 0xbe, 0x0e, 0x45, 0x34, 0x94, 0x87, 0x36, 0x78, 0x46, 0xb1, 0x67, 0x3a, 0x15, 0xd2, 0xea, 0x4f, - 0xb5, 0xd5, 0x25, 0x87, 0x16, 0x79, 0xf2, 0x1e, 0x40, 0xed, 0x8d, 0xb8, 0xa4, 0x58, 0x54, 0xa4, - 0x96, 0x11, 0xe9, 0x37, 0x16, 0xdc, 0x59, 0xec, 0x3e, 0x09, 0xce, 0x22, 0x71, 0x1a, 0x44, 0x33, - 0xc1, 0xb6, 0x55, 0xdc, 0x56, 0x99, 0xff, 0x87, 0x2b, 0x84, 0x05, 0x7b, 0xb4, 0xc0, 0x0e, 0xd5, - 0x6e, 0x6b, 0xb5, 0xec, 0xc8, 0xc3, 0x95, 0xac, 0x32, 0x36, 0xa1, 0xbe, 0xdf, 0xf7, 0xc9, 0xb4, - 0x6b, 0x77, 0xac, 0xae, 0x7d, 0xb8, 0xc2, 0x17, 0x1c, 0x76, 0x1f, 0x6a, 0x47, 0xb3, 0x54, 0x5c, - 0xf8, 0x3d, 0xaa, 0x08, 0xe7, 0x70, 0x85, 0x2b, 0x06, 0xee, 0xa4, 0xe5, 0x1b, 0x71, 0xe9, 0x56, - 0x3b, 0x56, 0xb7, 0x81, 0x3b, 0x15, 0x87, 0xb5, 0xc1, 0xd9, 0x8f, 0xe3, 0xc8, 0x5d, 0xed, 0x58, - 0xdd, 0x3a, 0x9e, 0x86, 0xd4, 0x7e, 0x0d, 0xaa, 0x64, 0xd8, 0xfb, 0x3b, 0xb4, 0xf3, 0xc1, 0x65, - 0xe9, 0x62, 0x60, 0xa3, 0x3d, 0x2b, 0xb3, 0x87, 0x04, 0xdb, 0xa0, 0x14, 0x56, 0xb2, 0xf3, 0x31, - 0x89, 0xcf, 0x60, 0x95, 0xcc, 0xc8, 0x22, 0x6f, 0x3e, 0x79, 0x50, 0x02, 0xb8, 0x86, 0x8c, 0x67, - 0xca, 0xfb, 0x0d, 0x42, 0xfc, 0x8f, 0x89, 0xdf, 0xf3, 0x7e, 0x53, 0x04, 0x97, 0x72, 0x89, 0x89, - 0x38, 0x0e, 0x46, 0x42, 0x9e, 0xcf, 0x69, 0x8d, 0xbc, 0x93, 0xcb, 0x89, 0x20, 0x07, 0x1a, 0x9c, - 0xd6, 0xde, 0x3f, 0x2c, 0x58, 0xcf, 0xef, 0x47, 0x9f, 0x8c, 0xea, 0xb8, 0xc6, 0x27, 0xd2, 0x5a, - 0x14, 0xcf, 0x8b, 0x62, 0xf1, 0x6c, 0x5d, 0xb5, 0xaf, 0x58, 0x3f, 0xbf, 0x05, 0xe7, 0x6d, 0x10, - 0x26, 0x4b, 0x15, 0xbe, 0x21, 0x21, 0xb4, 0xc9, 0x5d, 0x5b, 0xe6, 0xa2, 0xfa, 0x2a, 0x9e, 0x8d, - 0x53, 0x89, 0x21, 0x97, 0x84, 0x77, 0x00, 0x0d, 0xdc, 0x2f, 0x03, 0xf7, 0xa4, 0xb1, 0xac, 0xac, - 0x8c, 0xfe, 0x80, 0x5c, 0x2e, 0x0f, 0x6a, 0x43, 0x95, 0x94, 0x33, 0x24, 0x24, 0xe1, 0x1d, 0x02, - 0xa0, 0x74, 0x2a, 0xed, 0x6c, 0x43, 0x95, 0xa8, 0x0c, 0x84, 0xa2, 0x21, 0x29, 0xbc, 0xc2, 0xd2, - 0x03, 0xa8, 0xfa, 0xe3, 0xf4, 0xf9, 0x53, 0x14, 0xcb, 0x82, 0x44, 0x6f, 0x6c, 0x9e, 0x95, 0xcc, - 0x0c, 0xea, 0x12, 0xba, 0x78, 0xae, 0x0d, 0x58, 0x86, 0x01, 0xe4, 0x62, 0x5b, 0xe9, 0xa9, 0x38, - 0x89, 0xc0, 0x6b, 0xcb, 0xe3, 0xb9, 0x86, 0x24, 0xa3, 0xd8, 0xcf, 0xd4, 0x29, 0x0e, 0xc5, 0x7c, - 0xcb, 0xb8, 0x4a, 0xe8, 0x85, 0x3a, 0xf6, 0xcf, 0x00, 0xbf, 0x4f, 0xe2, 0xd9, 0x84, 0x40, 0x63, - 0x5d, 0xa8, 0x12, 0x95, 0xc5, 0xc7, 0xf4, 0x26, 0xe5, 0x1b, 0x97, 0x0a, 0xe5, 0xa0, 0x63, 0x72, - 0xfa, 0xb3, 0x91, 0xbc, 0x69, 0x1c, 0x97, 0x58, 0x4a, 0xf5, 0xd3, 0x20, 0x5a, 0x88, 0x4f, 0x83, - 0x28, 0x8b, 0x1b, 0x97, 0x79, 0x33, 0xb6, 0x32, 0x73, 0x1f, 0xea, 0xaf, 0xa3, 0x38, 0x48, 0x51, - 0x19, 0x6d, 0x59, 0x7c, 0x41, 0xb3, 0x5d, 0x80, 0x9e, 0x18, 0x84, 0xa3, 0x20, 0x42, 0xa9, 0x53, - 0x6c, 0x00, 0x99, 0x8c, 0x1b, 0x4a, 0xde, 0x33, 0xa8, 0x65, 0x54, 0x39, 0xf6, 0xc8, 0xed, 0x0f, - 0x82, 0x48, 0x28, 0x2f, 0x88, 0xf0, 0xde, 0xc1, 0x9a, 0x2c, 0x46, 0x7c, 0x3e, 0xfa, 0x22, 0xbd, - 0x41, 0x29, 0xde, 0xe8, 0x21, 0xf2, 0xfe, 0x65, 0x81, 0x83, 0x2b, 0x65, 0xc0, 0xd2, 0x06, 0xcc, - 0xdb, 0xe8, 0xc8, 0xdb, 0xc8, 0x3a, 0xd0, 0xec, 0xa7, 0xf8, 0x4e, 0xe9, 0x36, 0xd6, 0xe0, 0x26, - 0x0b, 0xf1, 0xf2, 0xc7, 0xa9, 0x4e, 0xb7, 0xcd, 0x17, 0x34, 0xdb, 0x84, 0x06, 0xf6, 0x26, 0x29, - 0xc4, 0x46, 0x56, 0xe7, 0x9a, 0xc1, 0xb6, 0x00, 0x14, 0xb2, 0x33, 0x41, 0xdd, 0xcc, 0xe2, 0x06, - 0xc7, 0x7b, 0x0c, 0x35, 0xf4, 0xf4, 0x28, 0x98, 0xe8, 0xd8, 0xac, 0xeb, 0x62, 0xfb, 0x6c, 0x41, - 0xeb, 0x4f, 0x33, 0x91, 0x5c, 0x72, 0xf1, 0xb7, 0x99, 0x98, 0xa6, 0x88, 0x2d, 0xd1, 0xaa, 0x96, - 0x89, 0xc0, 0xaa, 0xed, 0xbf, 0x0f, 0x92, 0xa1, 0x44, 0xca, 0xe1, 0x19, 0x85, 0xb1, 0x6a, 0xcc, - 0xa7, 0x14, 0x6b, 0x9d, 0x9b, 0x2c, 0xaa, 0x77, 0x31, 0x8a, 0x53, 0x15, 0x4c, 0x46, 0xb1, 0x2e, - 0xdc, 0x3a, 0xb8, 0x18, 0x44, 0xb3, 0xa1, 0xe0, 0xf1, 0x5c, 0xee, 0xa6, 0xe6, 0xcc, 0x8b, 0x6c, - 0xf6, 0x73, 0x6c, 0x6e, 0xc4, 0x52, 0xad, 0xa9, 0x46, 0x8a, 0x05, 0x2e, 0xdb, 0x85, 0xd6, 0xc1, - 0xe8, 0x4c, 0x0c, 0x87, 0x62, 0xd8, 0x0b, 0xd2, 0xc0, 0xad, 0x53, 0xdc, 0x85, 0x07, 0x3f, 0xa7, - 0xe2, 0x7d, 0xb4, 0x60, 0x2d, 0x8b, 0x7e, 0x3a, 0x89, 0xc7, 0x53, 0x81, 0x29, 0x3e, 0x48, 0x12, - 0x95, 0xe2, 0x83, 0x24, 0x61, 0x8f, 0xa1, 0xc6, 0xc5, 0x74, 0x16, 0xa5, 0xaa, 0x4a, 0xee, 0x6a, - 0x8b, 0x6a, 0xef, 0x2c, 0x4a, 0xb9, 0xd2, 0x62, 0xbf, 0x83, 0xf5, 0x5c, 0x1d, 0xaa, 0x67, 0xe1, - 0x27, 0x7a, 0x5f, 0x4e, 0xce, 0x0b, 0xea, 0xde, 0x67, 0x07, 0x9a, 0x86, 0xe5, 0x45, 0x91, 0x21, - 0x3e, 0x6b, 0x59, 0x91, 0x3d, 0xa4, 0xb9, 0xeb, 0x8a, 0xa9, 0x07, 0x7b, 0x52, 0x0b, 0xac, 0xe3, - 0xac, 0x2c, 0xad, 0x63, 0xdd, 0x08, 0xed, 0xeb, 0x1a, 0x21, 0x4e, 0x71, 0xef, 0x83, 0xf1, 0xb9, - 0x18, 0x52, 0x59, 0xd6, 0xb9, 0x22, 0xd9, 0x8e, 0xee, 0x0a, 0x94, 0xc7, 0x5c, 0xaf, 0x51, 0x12, - 0xae, 0x3b, 0x87, 0xec, 0x72, 0x38, 0x19, 0xd4, 0x64, 0xbd, 0x48, 0x8a, 0x3d, 0x87, 0xa6, 0x6e, - 0x5f, 0xd3, 0x2c, 0x45, 0x6d, 0x6d, 0x4a, 0x0b, 0xb9, 0xa9, 0xc8, 0x5e, 0x16, 0x47, 0x34, 0xb7, - 0x41, 0x5e, 0xb8, 0xb9, 0xc8, 0x0d, 0x39, 0x2f, 0x8e, 0x74, 0xbb, 0xc6, 0xcc, 0xe8, 0x02, 0x6d, - 0xbe, 0xa3, 0x37, 0x2f, 0x44, 0xdc, 0x98, 0x2c, 0x9f, 0x9a, 0x6f, 0x89, 0xdb, 0xa4, 0x3d, 0xed, - 0x3c, 0x72, 0x52, 0xc6, 0xcd, 0x37, 0x67, 0xd7, 0x78, 0xc8, 0xdc, 0x56, 0xf1, 0xa0, 0x85, 0x88, - 0x1b, 0xcf, 0x9d, 0x5f, 0x32, 0xdf, 0xb9, 0x6b, 0xb4, 0xb5, 0x7c, 0x78, 0x93, 0x2a, 0xbc, 0x64, - 0x2a, 0x7c, 0x59, 0x9c, 0x04, 0xdc, 0xf5, 0x22, 0x50, 0x79, 0x39, 0x2f, 0xe8, 0x7b, 0xff, 0xa9, - 0xc0, 0x9a, 0x3f, 0x9a, 0xc4, 0x49, 0x6a, 0xb4, 0x04, 0x7f, 0x3c, 0x14, 0x17, 0xaa, 0x25, 0x10, - 0x51, 0xfe, 0x6a, 0x52, 0x6b, 0xc6, 0xd6, 0x40, 0xad, 0xc0, 0xe1, 0x92, 0x30, 0xca, 0xc1, 0xc9, - 0x95, 0xc3, 0x26, 0x34, 0x64, 0xed, 0xa3, 0xa8, 0x4a, 0x22, 0xcd, 0x90, 0x1f, 0x00, 0x73, 0x1a, - 0x1c, 0x6b, 0x34, 0x8a, 0x2a, 0x12, 0xdb, 0xa0, 0x54, 0x23, 0x61, 0x9d, 0x84, 0x06, 0x07, 0xe5, - 0x27, 0xe1, 0x48, 0x4c, 0xd3, 0x60, 0x34, 0xc1, 0xbe, 0x62, 0x77, 0x6d, 0x6e, 0x70, 0xb0, 0xa5, - 0x50, 0x10, 0xaf, 0x12, 0x11, 0xa4, 0x62, 0xb8, 0x97, 0x52, 0x39, 0xd9, 0xbc, 0xc0, 0x45, 0x3d, - 0x0a, 0x4b, 0xeb, 0x81, 0xd4, 0xcb, 0x73, 0xe9, 0x59, 0x8c, 0x44, 0x90, 0x50, 0x91, 0xd4, 0xb9, - 0x24, 0xbc, 0xff, 0x57, 0x80, 0x49, 0x24, 0xe5, 0xe0, 0xf7, 0xa3, 0xc1, 0x79, 0x3d, 0x6c, 0x79, - 0x70, 0x6a, 0x4b, 0xe0, 0xdc, 0x5b, 0x8c, 0xab, 0x12, 0x98, 0x8c, 0xc2, 0x5e, 0xae, 0x5f, 0x12, - 0x89, 0xaa, 0xc5, 0x4d, 0x16, 0xf3, 0xa0, 0x65, 0x3c, 0x63, 0x78, 0x07, 0xd1, 0x76, 0x8e, 0x57, - 0x02, 0x2d, 0xdc, 0x10, 0xda, 0xe6, 0xf5, 0xd0, 0xb6, 0x4c, 0x68, 0x3f, 0x5a, 0xd0, 0xda, 0x4b, - 0xe3, 0x51, 0x38, 0xe0, 0x62, 0x10, 0x27, 0xc3, 0xab, 0x41, 0x95, 0xf0, 0x55, 0x4c, 0xf8, 0x76, - 0xc0, 0xf6, 0x3f, 0x24, 0x59, 0x2b, 0xdc, 0x34, 0x06, 0xad, 0xa5, 0x5c, 0x71, 0x54, 0x64, 0x8f, - 0xa0, 0xe2, 0x27, 0x54, 0xb9, 0xb9, 0x26, 0x9e, 0xbb, 0x24, 0xbc, 0xe2, 0x27, 0xde, 0xaf, 0xa0, - 0x2d, 0x9d, 0x52, 0xa2, 0xec, 0x51, 0x69, 0x43, 0xf5, 0x20, 0x49, 0x62, 0xf5, 0xac, 0x48, 0xc2, - 0xbb, 0x80, 0xf6, 0x49, 0x12, 0x8c, 0xa7, 0x51, 0x90, 0x0a, 0x4c, 0xcc, 0xd7, 0xd4, 0x47, 0xd9, - 0xd7, 0x75, 0x07, 0x9a, 0xc7, 0x71, 0xfa, 0x2e, 0x09, 0x53, 0xba, 0xff, 0xb2, 0x93, 0x9b, 0x2c, - 0xef, 0x17, 0x70, 0xb7, 0x70, 0xb2, 0x7e, 0xfd, 0xb0, 0xa4, 0x6c, 0xfd, 0x15, 0xdb, 0x87, 0x3b, - 0x0b, 0x55, 0xbf, 0xf7, 0x55, 0x3e, 0x2e, 0x1b, 0xfd, 0xa5, 0x11, 0x39, 0x19, 0xcd, 0x8e, 0x2f, - 0x89, 0xc6, 0xdb, 0x07, 0x37, 0x43, 0x53, 0x7e, 0xfc, 0x67, 0x1e, 0x9c, 0x86, 0x62, 0x7e, 0xd5, - 0xf7, 0x11, 0xbd, 0xfe, 0x15, 0xfa, 0x65, 0x40, 0x6b, 0xef, 0x7b, 0x0b, 0xda, 0x65, 0x46, 0x74, - 0x71, 0x59, 0x46, 0x71, 0xb1, 0x17, 0x50, 0xfd, 0x10, 0x8a, 0xb9, 0x7a, 0xef, 0xbd, 0xa5, 0x94, - 0x2f, 0x79, 0xc2, 0xe5, 0x06, 0xbc, 0x5a, 0x7b, 0x83, 0x34, 0x8c, 0xc7, 0x6a, 0xb8, 0x97, 0x14, - 0x9e, 0xb3, 0x1f, 0xc5, 0x83, 0xbf, 0xca, 0xcf, 0x56, 0x2e, 0x89, 0x92, 0xab, 0x52, 0xbd, 0xe1, - 0x55, 0x59, 0x2d, 0xbb, 0x2a, 0xde, 0xbf, 0x2d, 0x85, 0x95, 0x31, 0x80, 0x7d, 0x31, 0x63, 0xfa, - 0x82, 0xd8, 0xea, 0x82, 0xb8, 0x72, 0x8a, 0xd4, 0xc3, 0xb2, 0x22, 0x71, 0x72, 0xc5, 0x25, 0xfd, - 0xb3, 0x70, 0x28, 0x4b, 0x0b, 0xfa, 0x0b, 0x5d, 0x69, 0x39, 0xd8, 0xd5, 0xb2, 0x60, 0xf7, 0x37, - 0xfe, 0xfb, 0x69, 0xcb, 0xfa, 0xdf, 0xa7, 0x2d, 0xeb, 0xdb, 0x4f, 0x5b, 0xd6, 0x3f, 0xbf, 0xdb, - 0x5a, 0x39, 0x5b, 0xa5, 0x7f, 0x4e, 0xbf, 0xfe, 0x21, 0x00, 0x00, 0xff, 0xff, 0x51, 0x90, 0x81, - 0x4c, 0x83, 0x12, 0x00, 0x00, + 0x11, 0x37, 0x45, 0xca, 0x92, 0x46, 0xb2, 0xe3, 0xb7, 0xd1, 0x7b, 0x25, 0x52, 0xc7, 0x4f, 0x25, + 0xdc, 0x3e, 0xb5, 0x28, 0x1c, 0x38, 0x4d, 0x82, 0x5c, 0xda, 0xc6, 0x8e, 0x9c, 0x9a, 0x48, 0xed, + 0xa6, 0x2b, 0xc3, 0xb9, 0x15, 0xa0, 0xa5, 0xad, 0x43, 0x94, 0x12, 0x55, 0x8a, 0x8a, 0xec, 0x4b, + 0x81, 0x7e, 0x86, 0x5c, 0xfa, 0x11, 0x7a, 0xea, 0x87, 0xe8, 0xa5, 0x3d, 0xf6, 0x58, 0xa0, 0x97, + 0x22, 0xed, 0xb7, 0xe8, 0xa5, 0x98, 0x59, 0x2e, 0x77, 0x49, 0xd1, 0x8e, 0x11, 0xbc, 0xdb, 0xce, + 0x9f, 0x9d, 0x9d, 0xf9, 0xcd, 0xec, 0xec, 0x90, 0xd0, 0x99, 0x2d, 0x2e, 0xa2, 0x70, 0xb4, 0x37, + 0x4b, 0xe2, 0x34, 0x66, 0xcd, 0x70, 0x9a, 0x8a, 0x64, 0x1a, 0x44, 0xde, 0x1c, 0x6c, 0x1e, 0x2f, + 0x99, 0x0b, 0x8d, 0x97, 0x71, 0xb4, 0x98, 0x4c, 0xe7, 0xae, 0xd5, 0xb3, 0xfb, 0x0e, 0x57, 0x24, + 0x63, 0xe0, 0xbc, 0x16, 0xd7, 0x73, 0xd7, 0xee, 0xd9, 0xfd, 0x16, 0xa7, 0x35, 0xdb, 0x85, 0xfa, + 0x41, 0x9a, 0x26, 0x73, 0xb7, 0xd6, 0xb3, 0xfb, 0xed, 0xc7, 0x9b, 0x7b, 0xca, 0xdc, 0x1e, 0xb2, + 0xb9, 0x14, 0xa2, 0x4d, 0x1e, 0x07, 0x49, 0x38, 0xbd, 0x74, 0x9d, 0x9e, 0xd5, 0xef, 0x70, 0x45, + 0x7a, 0x7b, 0xd0, 0xe2, 0xf1, 0xf2, 0x24, 0x48, 0x93, 0xf0, 0x8a, 0x7d, 0x0f, 0x1c, 0x1e, 0x2f, + 0xe5, 0xb9, 0xed, 0xc7, 0x1b, 0xda, 0x16, 0x8f, 0x97, 0x9c, 0x44, 0xde, 0x09, 0xb4, 0x86, 0xe1, + 0xe5, 0x54, 0x8c, 0xd1, 0xd5, 0xaf, 0xc1, 0x7e, 0x13, 0xa3, 0xba, 0xb5, 0xaa, 0x8e, 0x12, 0x54, + 0x38, 0x15, 0x97, 0x6e, 0xad, 0x52, 0xe1, 0x54, 0x5c, 0x7a, 0xcf, 0x61, 0x93, 0xc7, 0x4b, 0x7f, + 0x2c, 0xa6, 0x69, 0xf8, 0xdb, 0x50, 0x24, 0x14, 0x64, 0xee, 0x83, 0x23, 0x0f, 0xcd, 0x03, 0xaf, + 0xe9, 0xc0, 0xbd, 0x07, 0xb0, 0xee, 0x0f, 0x7e, 0x19, 0xce, 0x53, 0xb6, 0x05, 0xb6, 0x3f, 0x50, + 0x1b, 0x70, 0xe9, 0xf9, 0xf0, 0xc5, 0xd1, 0x55, 0x9a, 0x04, 0xa3, 0x54, 0x8c, 0xfd, 0x81, 0x84, + 0x8f, 0x6d, 0x42, 0xcd, 0x1f, 0x90, 0xaf, 0x0e, 0xaf, 0xf9, 0x03, 0xb6, 0x0b, 0xce, 0x79, 0x10, + 0x29, 0xe0, 0xb6, 0xb4, 0x73, 0xd2, 0x2c, 0x27, 0xa9, 0x77, 0x51, 0x30, 0x95, 0xe1, 0xf4, 0x15, + 0xac, 0xbf, 0x0a, 0x45, 0x34, 0x96, 0x87, 0xb6, 0x78, 0x46, 0xb1, 0xa7, 0x3a, 0x75, 0xd2, 0xea, + 0x77, 0xb5, 0xd5, 0x15, 0x87, 0xf2, 0xbc, 0x7a, 0x0f, 0xa1, 0xf1, 0x5a, 0x5c, 0x53, 0x2c, 0x2a, + 0x52, 0xcb, 0x88, 0xf4, 0x5f, 0x16, 0xdc, 0xcf, 0x77, 0x9f, 0x05, 0x17, 0x91, 0x38, 0x0f, 0xa2, + 0x85, 0x60, 0xbb, 0x2a, 0x6e, 0xab, 0xca, 0xff, 0xe3, 0x35, 0xc2, 0x82, 0x7d, 0x93, 0x63, 0x87, + 0x6a, 0x5f, 0x68, 0xb5, 0xec, 0xc8, 0xe3, 0xb5, 0xac, 0x92, 0xb6, 0xa1, 0x79, 0x38, 0xf4, 0xc9, + 0xb4, 0x6b, 0xf7, 0xac, 0xbe, 0x7d, 0xbc, 0xc6, 0x73, 0x0e, 0x7b, 0x00, 0x8d, 0x93, 0x45, 0x2a, + 0xae, 0xfc, 0x01, 0x55, 0x90, 0x73, 0xbc, 0xc6, 0x15, 0x03, 0x77, 0xd2, 0xf2, 0xb5, 0xb8, 0x76, + 0xeb, 0x3d, 0xab, 0xdf, 0xc2, 0x9d, 0x8a, 0xc3, 0xba, 0xe0, 0x1c, 0xc6, 0x71, 0xe4, 0xae, 0xf7, + 0xac, 0x7e, 0x13, 0x4f, 0x43, 0xea, 0xb0, 0x01, 0x75, 0x32, 0xec, 0xfd, 0x01, 0xba, 0xc5, 0xe0, + 0xb2, 0x74, 0x31, 0xb0, 0xd1, 0x9e, 0x95, 0xd9, 0x43, 0x82, 0x6d, 0x51, 0x0a, 0x6b, 0xd9, 0xf9, + 0x98, 0xc4, 0xa7, 0xb0, 0x4e, 0x66, 0xe4, 0xa5, 0x68, 0x3f, 0x7e, 0x58, 0x01, 0xb8, 0x86, 0x8c, + 0x67, 0xca, 0x87, 0x2d, 0x42, 0xfc, 0x57, 0x89, 0x3f, 0xf0, 0x7e, 0x5a, 0x06, 0x97, 0x72, 0x89, + 0x89, 0x38, 0x0d, 0x26, 0x42, 0x9e, 0xcf, 0x69, 0x8d, 0xbc, 0xb3, 0xeb, 0x99, 0x20, 0x07, 0x5a, + 0x9c, 0xd6, 0xde, 0x1f, 0x2d, 0xd8, 0x2c, 0xee, 0x47, 0x9f, 0x8c, 0xea, 0xb8, 0xc5, 0x27, 0xd2, + 0xca, 0x8b, 0xe7, 0x79, 0xb9, 0x78, 0x76, 0x6e, 0xda, 0x57, 0xae, 0x9f, 0x9f, 0x81, 0xf3, 0x26, + 0x08, 0x93, 0x95, 0x0a, 0xdf, 0x92, 0x10, 0xda, 0xe4, 0xae, 0x2d, 0x73, 0x51, 0x7f, 0x19, 0x2f, + 0xa6, 0xa9, 0xc4, 0x90, 0x4b, 0xc2, 0x3b, 0x82, 0x16, 0xee, 0x97, 0x81, 0x7b, 0xd2, 0x58, 0x56, + 0x56, 0x46, 0x3f, 0x41, 0x2e, 0x97, 0x07, 0x75, 0xa1, 0x4e, 0xca, 0x19, 0x12, 0x92, 0xf0, 0x8e, + 0x01, 0x50, 0x3a, 0x97, 0x76, 0x76, 0xa1, 0x4e, 0x54, 0x06, 0x42, 0xd9, 0x90, 0x14, 0xde, 0x60, + 0xe9, 0x21, 0xd4, 0xfd, 0x69, 0xfa, 0xec, 0x09, 0x8a, 0x65, 0x41, 0xa2, 0x37, 0x36, 0xcf, 0x4a, + 0x66, 0x01, 0x4d, 0x09, 0x5d, 0xbc, 0xd4, 0x06, 0x2c, 0xc3, 0x00, 0x72, 0xb1, 0xad, 0x0c, 0x54, + 0x9c, 0x44, 0xe0, 0xb5, 0xe5, 0xf1, 0x52, 0x43, 0x92, 0x51, 0xec, 0xfb, 0xea, 0x14, 0x87, 0x62, + 0xbe, 0x67, 0x5c, 0x25, 0xf4, 0x42, 0x1d, 0xfb, 0x1b, 0x80, 0x5f, 0x24, 0xf1, 0x62, 0x46, 0xa0, + 0xb1, 0x3e, 0xd4, 0x89, 0xca, 0xe2, 0x63, 0x7a, 0x93, 0xf2, 0x8d, 0x4b, 0x85, 0x6a, 0xd0, 0x31, + 0x39, 0xc3, 0xc5, 0x44, 0xde, 0x34, 0x8e, 0x4b, 0x2c, 0xa5, 0xe6, 0x79, 0x10, 0xe5, 0xe2, 0xf3, + 0x20, 0xca, 0xe2, 0xc6, 0x65, 0xd1, 0x8c, 0xad, 0xcc, 0x3c, 0x80, 0xe6, 0xab, 0x28, 0x0e, 0x52, + 0x54, 0x46, 0x5b, 0x16, 0xcf, 0x69, 0xb6, 0x0f, 0x30, 0x10, 0xa3, 0x70, 0x12, 0x44, 0x28, 0x75, + 0xca, 0x0d, 0x20, 0x93, 0x71, 0x43, 0xc9, 0x7b, 0x0a, 0x8d, 0x8c, 0xaa, 0xc6, 0x1e, 0xb9, 0xc3, + 0x51, 0x10, 0x09, 0xe5, 0x05, 0x11, 0xde, 0x5b, 0xd8, 0x90, 0xc5, 0x88, 0xcf, 0xcd, 0x50, 0xa4, + 0x77, 0x28, 0xc5, 0x3b, 0x3d, 0x5c, 0xde, 0x9f, 0x2d, 0x70, 0x70, 0xa5, 0x0c, 0x58, 0xda, 0x80, + 0x79, 0x1b, 0x1d, 0x79, 0x1b, 0x59, 0x0f, 0xda, 0xc3, 0x14, 0xdf, 0x35, 0xdd, 0xc6, 0x5a, 0xdc, + 0x64, 0x21, 0x5e, 0xfe, 0x34, 0xd5, 0xe9, 0xb6, 0x79, 0x4e, 0xb3, 0x6d, 0x68, 0x61, 0x6f, 0x92, + 0x42, 0x6c, 0x64, 0x4d, 0xae, 0x19, 0x6c, 0x07, 0x40, 0x21, 0xbb, 0x10, 0xd4, 0xcd, 0x2c, 0x6e, + 0x70, 0xbc, 0x47, 0xd0, 0x40, 0x4f, 0x4f, 0x82, 0x99, 0x8e, 0xcd, 0xba, 0x2d, 0xb6, 0xff, 0x59, + 0xd0, 0xf9, 0xf5, 0x42, 0x24, 0xd7, 0x5c, 0xfc, 0x7e, 0x21, 0xe6, 0x29, 0x62, 0x4b, 0xb4, 0xaa, + 0x65, 0x22, 0xb0, 0x6a, 0x87, 0xef, 0x82, 0x64, 0x2c, 0x91, 0x72, 0x78, 0x46, 0x61, 0xac, 0x1a, + 0xf3, 0x39, 0xc5, 0xda, 0xe4, 0x26, 0x8b, 0xea, 0x5d, 0x4c, 0xe2, 0x54, 0x05, 0x93, 0x51, 0xac, + 0x0f, 0xf7, 0x8e, 0xae, 0x46, 0xd1, 0x62, 0x2c, 0x78, 0xbc, 0x94, 0xbb, 0xa9, 0x39, 0xf3, 0x32, + 0x9b, 0xfd, 0x00, 0x9b, 0x1b, 0xb1, 0x54, 0x6b, 0x6a, 0x90, 0x62, 0x89, 0xcb, 0xf6, 0xa1, 0x73, + 0x34, 0xb9, 0x10, 0xe3, 0xb1, 0x18, 0x0f, 0x82, 0x34, 0x70, 0x9b, 0x55, 0x03, 0x44, 0x41, 0xc5, + 0xfb, 0x60, 0xc1, 0x46, 0x16, 0xfd, 0x7c, 0x16, 0x4f, 0xe7, 0x02, 0x53, 0x7c, 0x94, 0x24, 0x2a, + 0xc5, 0x47, 0x49, 0xc2, 0x1e, 0x41, 0x83, 0x8b, 0xf9, 0x22, 0x4a, 0x55, 0x95, 0x7c, 0xa9, 0x2d, + 0xaa, 0xbd, 0x8b, 0x28, 0xe5, 0x4a, 0x8b, 0xfd, 0x1c, 0x36, 0x0b, 0x75, 0xa8, 0x9e, 0x85, 0xef, + 0xe8, 0x7d, 0x05, 0x39, 0x2f, 0xa9, 0x7b, 0x7f, 0xa9, 0x43, 0xdb, 0xb0, 0x9c, 0x17, 0x19, 0xe2, + 0xb3, 0x91, 0x15, 0xd9, 0xd7, 0x34, 0xa7, 0xdd, 0x30, 0xf5, 0x60, 0x4f, 0xea, 0x80, 0x75, 0x9a, + 0x95, 0xa5, 0x75, 0xaa, 0x1b, 0xa1, 0x7d, 0x5b, 0x23, 0xc4, 0xa9, 0xef, 0x5d, 0x30, 0xbd, 0x14, + 0x63, 0x2a, 0xcb, 0x26, 0x57, 0x24, 0xdb, 0xd3, 0x5d, 0x81, 0xf2, 0x58, 0xe8, 0x35, 0x4a, 0xc2, + 0x75, 0xe7, 0x90, 0x5d, 0x0e, 0x27, 0x83, 0x86, 0xac, 0x17, 0x49, 0xb1, 0x67, 0xd0, 0xd6, 0xed, + 0x6b, 0x9e, 0xa5, 0xa8, 0xab, 0x4d, 0x69, 0x21, 0x37, 0x15, 0xd9, 0x8b, 0xf2, 0x88, 0xe6, 0xb6, + 0xc8, 0x0b, 0xb7, 0x10, 0xb9, 0x21, 0xe7, 0xe5, 0x91, 0x6e, 0xdf, 0x98, 0x19, 0x5d, 0xa0, 0xcd, + 0xf7, 0xf5, 0xe6, 0x5c, 0xc4, 0x8d, 0xc9, 0xf2, 0x89, 0xf9, 0x96, 0xb8, 0x6d, 0xda, 0xd3, 0x2d, + 0x22, 0x27, 0x65, 0xdc, 0x7c, 0x73, 0xf6, 0x8d, 0x87, 0xcc, 0xed, 0x94, 0x0f, 0xca, 0x45, 0xdc, + 0x78, 0xee, 0xfc, 0x8a, 0xf9, 0xce, 0xdd, 0xa0, 0xad, 0xd5, 0xc3, 0x9b, 0x54, 0xe1, 0x15, 0x53, + 0xe1, 0x8b, 0xf2, 0x24, 0xe0, 0x6e, 0x96, 0x81, 0x2a, 0xca, 0x79, 0x79, 0x72, 0xd8, 0x37, 0x86, + 0x71, 0xf7, 0x5e, 0xd9, 0xff, 0x5c, 0xc4, 0xb5, 0x96, 0xf7, 0xb7, 0x1a, 0x6c, 0xf8, 0x93, 0x59, + 0x9c, 0xa4, 0x46, 0x17, 0xf1, 0xa7, 0x63, 0x71, 0xa5, 0xba, 0x08, 0x11, 0xd5, 0x0f, 0x2d, 0x75, + 0x73, 0xec, 0x26, 0xd4, 0x3d, 0x1c, 0x2e, 0x09, 0xa3, 0x82, 0x9c, 0x42, 0x05, 0x6d, 0x43, 0x4b, + 0x5e, 0x17, 0x14, 0xd5, 0x49, 0xa4, 0x19, 0xf2, 0x1b, 0x63, 0x49, 0xb3, 0x66, 0x83, 0xa6, 0x57, + 0x45, 0x62, 0xe7, 0x94, 0x6a, 0x24, 0x6c, 0x92, 0xd0, 0xe0, 0xa0, 0xfc, 0x2c, 0x9c, 0x88, 0x79, + 0x1a, 0x4c, 0x66, 0xd8, 0x8a, 0xec, 0xbe, 0xcd, 0x0d, 0x0e, 0x76, 0x21, 0x0a, 0xe2, 0x65, 0x22, + 0x82, 0x54, 0x8c, 0x0f, 0x52, 0xaa, 0x40, 0x9b, 0x97, 0xb8, 0xa8, 0x47, 0x61, 0x69, 0x3d, 0x90, + 0x7a, 0x45, 0x2e, 0xbd, 0xa4, 0x91, 0x08, 0x12, 0xaa, 0xab, 0x26, 0x97, 0x84, 0xf7, 0xcf, 0x1a, + 0x30, 0x89, 0xa4, 0x9c, 0x15, 0xbf, 0x35, 0x38, 0x6f, 0x87, 0xad, 0x08, 0x4e, 0x63, 0x05, 0x9c, + 0xaf, 0xf2, 0x09, 0x57, 0x02, 0x93, 0x51, 0xd8, 0xfe, 0xf5, 0xe3, 0x23, 0x51, 0xb5, 0xb8, 0xc9, + 0x62, 0x1e, 0x74, 0x8c, 0x97, 0x0f, 0xaf, 0x2d, 0xda, 0x2e, 0xf0, 0x2a, 0xa0, 0x85, 0x3b, 0x42, + 0xdb, 0xbe, 0x1d, 0xda, 0x8e, 0x09, 0xed, 0x07, 0x0b, 0x3a, 0x07, 0x69, 0x3c, 0x09, 0x47, 0x5c, + 0x8c, 0xe2, 0x64, 0x7c, 0x33, 0xa8, 0x12, 0xbe, 0x9a, 0x09, 0xdf, 0x1e, 0xd8, 0xfe, 0xfb, 0x24, + 0xeb, 0x9e, 0xdb, 0xc6, 0x6c, 0xb6, 0x92, 0x2b, 0x8e, 0x8a, 0xec, 0x1b, 0xa8, 0xf9, 0x09, 0x55, + 0x6e, 0xa1, 0xef, 0x17, 0x2e, 0x09, 0xaf, 0xf9, 0x89, 0xf7, 0x63, 0xe8, 0x4a, 0xa7, 0x94, 0x28, + 0x7b, 0x87, 0xba, 0x50, 0x3f, 0x4a, 0x92, 0x58, 0xbd, 0x44, 0x92, 0xf0, 0xae, 0xa0, 0x7b, 0x96, + 0x04, 0xd3, 0x79, 0x14, 0xa4, 0x02, 0x13, 0xf3, 0x39, 0xf5, 0x51, 0xf5, 0x01, 0xdf, 0x83, 0xf6, + 0x69, 0x9c, 0xbe, 0x4d, 0xc2, 0x94, 0x5a, 0x86, 0x6c, 0xfe, 0x26, 0xcb, 0xfb, 0x21, 0x7c, 0x59, + 0x3a, 0x59, 0x3f, 0x98, 0x58, 0x52, 0xb6, 0xfe, 0xf0, 0x1d, 0xc2, 0xfd, 0x5c, 0xd5, 0x1f, 0x7c, + 0x96, 0x8f, 0xab, 0x46, 0x7f, 0x64, 0x44, 0x4e, 0x46, 0xb3, 0xe3, 0x2b, 0xa2, 0xf1, 0x0e, 0xc1, + 0xcd, 0xd0, 0x94, 0xff, 0x17, 0x32, 0x0f, 0xce, 0x43, 0xb1, 0xbc, 0xe9, 0x93, 0x8a, 0x06, 0x86, + 0x1a, 0xfd, 0x95, 0xa0, 0xb5, 0xf7, 0x5f, 0x0b, 0xba, 0x55, 0x46, 0x74, 0x71, 0x59, 0x46, 0x71, + 0xb1, 0xe7, 0x50, 0x7f, 0x1f, 0x8a, 0xa5, 0x1a, 0x11, 0xbc, 0x95, 0x94, 0xaf, 0x78, 0xc2, 0xe5, + 0x06, 0xbc, 0x5a, 0x07, 0xa3, 0x34, 0x8c, 0xa7, 0xea, 0x7b, 0x40, 0x52, 0x78, 0xce, 0x61, 0x14, + 0x8f, 0x7e, 0x27, 0xbf, 0x74, 0xb9, 0x24, 0x2a, 0xae, 0x4a, 0xfd, 0x8e, 0x57, 0x65, 0xbd, 0xea, + 0xaa, 0x78, 0x7f, 0xb5, 0x14, 0x56, 0xc6, 0xcc, 0xf6, 0xc9, 0x8c, 0xe9, 0x0b, 0x62, 0xab, 0x0b, + 0xe2, 0xca, 0xc1, 0x53, 0xcf, 0xd7, 0x8a, 0xc4, 0x61, 0x17, 0x97, 0xf4, 0x9b, 0xc3, 0xa1, 0x2c, + 0xe5, 0xf4, 0x27, 0xba, 0xd2, 0x6a, 0xb0, 0xeb, 0x55, 0xc1, 0x1e, 0x6e, 0xfd, 0xfd, 0xe3, 0x8e, + 0xf5, 0x8f, 0x8f, 0x3b, 0xd6, 0xbf, 0x3f, 0xee, 0x58, 0x7f, 0xfa, 0xcf, 0xce, 0xda, 0xc5, 0x3a, + 0xfd, 0xd6, 0xfa, 0xc9, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0xf4, 0x59, 0xf3, 0x5b, 0xe6, 0x12, + 0x00, 0x00, } func (m *Row) Marshal() (dAtA []byte, err error) { @@ -2793,6 +2851,47 @@ func (m *Row) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *RowMatrix) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RowMatrix) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RowMatrix) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Rows) > 0 { + for iNdEx := len(m.Rows) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Rows[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPublic(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + func (m *SignedRow) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -4104,6 +4203,18 @@ func (m *QueryResult) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + if m.RowMatrix != nil { + { + size, err := m.RowMatrix.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPublic(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x7a + } if m.ExtractedTable != nil { { size, err := m.ExtractedTable.MarshalToSizedBuffer(dAtA[:i]) @@ -4191,20 +4302,20 @@ func (m *QueryResult) MarshalToSizedBuffer(dAtA []byte) (int, error) { } } if len(m.RowIDs) > 0 { - dAtA23 := make([]byte, len(m.RowIDs)*10) - var j22 int + dAtA24 := make([]byte, len(m.RowIDs)*10) + var j23 int for _, num := range m.RowIDs { for num >= 1<<7 { - dAtA23[j22] = uint8(uint64(num)&0x7f | 0x80) + dAtA24[j23] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j22++ + j23++ } - dAtA23[j22] = uint8(num) - j22++ + dAtA24[j23] = uint8(num) + j23++ } - i -= j22 - copy(dAtA[i:], dAtA23[:j22]) - i = encodeVarintPublic(dAtA, i, uint64(j22)) + i -= j23 + copy(dAtA[i:], dAtA24[:j23]) + i = encodeVarintPublic(dAtA, i, uint64(j23)) i-- dAtA[i] = 0x3a } @@ -4332,57 +4443,57 @@ func (m *ImportRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { } } if len(m.Timestamps) > 0 { - dAtA27 := make([]byte, len(m.Timestamps)*10) - var j26 int + dAtA28 := make([]byte, len(m.Timestamps)*10) + var j27 int for _, num1 := range m.Timestamps { num := uint64(num1) for num >= 1<<7 { - dAtA27[j26] = uint8(uint64(num)&0x7f | 0x80) + dAtA28[j27] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j26++ + j27++ } - dAtA27[j26] = uint8(num) - j26++ + dAtA28[j27] = uint8(num) + j27++ } - i -= j26 - copy(dAtA[i:], dAtA27[:j26]) - i = encodeVarintPublic(dAtA, i, uint64(j26)) + i -= j27 + copy(dAtA[i:], dAtA28[:j27]) + i = encodeVarintPublic(dAtA, i, uint64(j27)) i-- dAtA[i] = 0x32 } if len(m.ColumnIDs) > 0 { - dAtA29 := make([]byte, len(m.ColumnIDs)*10) - var j28 int + dAtA30 := make([]byte, len(m.ColumnIDs)*10) + var j29 int for _, num := range m.ColumnIDs { for num >= 1<<7 { - dAtA29[j28] = uint8(uint64(num)&0x7f | 0x80) + dAtA30[j29] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j28++ + j29++ } - dAtA29[j28] = uint8(num) - j28++ + dAtA30[j29] = uint8(num) + j29++ } - i -= j28 - copy(dAtA[i:], dAtA29[:j28]) - i = encodeVarintPublic(dAtA, i, uint64(j28)) + i -= j29 + copy(dAtA[i:], dAtA30[:j29]) + i = encodeVarintPublic(dAtA, i, uint64(j29)) i-- dAtA[i] = 0x2a } if len(m.RowIDs) > 0 { - dAtA31 := make([]byte, len(m.RowIDs)*10) - var j30 int + dAtA32 := make([]byte, len(m.RowIDs)*10) + var j31 int for _, num := range m.RowIDs { for num >= 1<<7 { - dAtA31[j30] = uint8(uint64(num)&0x7f | 0x80) + dAtA32[j31] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j30++ + j31++ } - dAtA31[j30] = uint8(num) - j30++ + dAtA32[j31] = uint8(num) + j31++ } - i -= j30 - copy(dAtA[i:], dAtA31[:j30]) - i = encodeVarintPublic(dAtA, i, uint64(j30)) + i -= j31 + copy(dAtA[i:], dAtA32[:j31]) + i = encodeVarintPublic(dAtA, i, uint64(j31)) i-- dAtA[i] = 0x22 } @@ -4463,9 +4574,9 @@ func (m *ImportValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { } if len(m.FloatValues) > 0 { for iNdEx := len(m.FloatValues) - 1; iNdEx >= 0; iNdEx-- { - f32 := math.Float64bits(float64(m.FloatValues[iNdEx])) + f33 := math.Float64bits(float64(m.FloatValues[iNdEx])) i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f32)) + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f33)) } i = encodeVarintPublic(dAtA, i, uint64(len(m.FloatValues)*8)) i-- @@ -4481,39 +4592,39 @@ func (m *ImportValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { } } if len(m.Values) > 0 { - dAtA34 := make([]byte, len(m.Values)*10) - var j33 int + dAtA35 := make([]byte, len(m.Values)*10) + var j34 int for _, num1 := range m.Values { num := uint64(num1) for num >= 1<<7 { - dAtA34[j33] = uint8(uint64(num)&0x7f | 0x80) + dAtA35[j34] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j33++ + j34++ } - dAtA34[j33] = uint8(num) - j33++ + dAtA35[j34] = uint8(num) + j34++ } - i -= j33 - copy(dAtA[i:], dAtA34[:j33]) - i = encodeVarintPublic(dAtA, i, uint64(j33)) + i -= j34 + copy(dAtA[i:], dAtA35[:j34]) + i = encodeVarintPublic(dAtA, i, uint64(j34)) i-- dAtA[i] = 0x32 } if len(m.ColumnIDs) > 0 { - dAtA36 := make([]byte, len(m.ColumnIDs)*10) - var j35 int + dAtA37 := make([]byte, len(m.ColumnIDs)*10) + var j36 int for _, num := range m.ColumnIDs { for num >= 1<<7 { - dAtA36[j35] = uint8(uint64(num)&0x7f | 0x80) + dAtA37[j36] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j35++ + j36++ } - dAtA36[j35] = uint8(num) - j35++ + dAtA37[j36] = uint8(num) + j36++ } - i -= j35 - copy(dAtA[i:], dAtA36[:j35]) - i = encodeVarintPublic(dAtA, i, uint64(j35)) + i -= j36 + copy(dAtA[i:], dAtA37[:j36]) + i = encodeVarintPublic(dAtA, i, uint64(j36)) i-- dAtA[i] = 0x2a } @@ -4725,20 +4836,20 @@ func (m *TranslateKeysResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { copy(dAtA[i:], m.XXX_unrecognized) } if len(m.IDs) > 0 { - dAtA38 := make([]byte, len(m.IDs)*10) - var j37 int + dAtA39 := make([]byte, len(m.IDs)*10) + var j38 int for _, num := range m.IDs { for num >= 1<<7 { - dAtA38[j37] = uint8(uint64(num)&0x7f | 0x80) + dAtA39[j38] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j37++ + j38++ } - dAtA38[j37] = uint8(num) - j37++ + dAtA39[j38] = uint8(num) + j38++ } - i -= j37 - copy(dAtA[i:], dAtA38[:j37]) - i = encodeVarintPublic(dAtA, i, uint64(j37)) + i -= j38 + copy(dAtA[i:], dAtA39[:j38]) + i = encodeVarintPublic(dAtA, i, uint64(j38)) i-- dAtA[i] = 0x1a } @@ -4770,20 +4881,20 @@ func (m *TranslateIDsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { copy(dAtA[i:], m.XXX_unrecognized) } if len(m.IDs) > 0 { - dAtA40 := make([]byte, len(m.IDs)*10) - var j39 int + dAtA41 := make([]byte, len(m.IDs)*10) + var j40 int for _, num := range m.IDs { for num >= 1<<7 { - dAtA40[j39] = uint8(uint64(num)&0x7f | 0x80) + dAtA41[j40] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j39++ + j40++ } - dAtA40[j39] = uint8(num) - j39++ + dAtA41[j40] = uint8(num) + j40++ } - i -= j39 - copy(dAtA[i:], dAtA40[:j39]) - i = encodeVarintPublic(dAtA, i, uint64(j39)) + i -= j40 + copy(dAtA[i:], dAtA41[:j40]) + i = encodeVarintPublic(dAtA, i, uint64(j40)) i-- dAtA[i] = 0x1a } @@ -4984,20 +5095,20 @@ func (m *ImportColumnAttrsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error dAtA[i] = 0x30 } if len(m.ColumnIDs) > 0 { - dAtA42 := make([]byte, len(m.ColumnIDs)*10) - var j41 int + dAtA43 := make([]byte, len(m.ColumnIDs)*10) + var j42 int for _, num := range m.ColumnIDs { for num >= 1<<7 { - dAtA42[j41] = uint8(uint64(num)&0x7f | 0x80) + dAtA43[j42] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j41++ + j42++ } - dAtA42[j41] = uint8(num) - j41++ + dAtA43[j42] = uint8(num) + j42++ } - i -= j41 - copy(dAtA[i:], dAtA42[:j41]) - i = encodeVarintPublic(dAtA, i, uint64(j41)) + i -= j42 + copy(dAtA[i:], dAtA43[:j42]) + i = encodeVarintPublic(dAtA, i, uint64(j42)) i-- dAtA[i] = 0x2a } @@ -5078,6 +5189,24 @@ func (m *Row) Size() (n int) { return n } +func (m *RowMatrix) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Rows) > 0 { + for _, e := range m.Rows { + l = e.Size() + n += 1 + l + sovPublic(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + func (m *SignedRow) Size() (n int) { if m == nil { return 0 @@ -5748,6 +5877,10 @@ func (m *QueryResult) Size() (n int) { l = m.ExtractedTable.Size() n += 1 + l + sovPublic(uint64(l)) } + if m.RowMatrix != nil { + l = m.RowMatrix.Size() + n += 1 + l + sovPublic(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -6349,6 +6482,94 @@ func (m *Row) Unmarshal(dAtA []byte) error { } return nil } +func (m *RowMatrix) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPublic + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RowMatrix: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RowMatrix: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Rows", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPublic + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPublic + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPublic + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Rows = append(m.Rows, &Row{}) + if err := m.Rows[len(m.Rows)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPublic(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthPublic + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthPublic + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *SignedRow) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -10009,6 +10230,42 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RowMatrix", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPublic + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPublic + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPublic + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RowMatrix == nil { + m.RowMatrix = &RowMatrix{} + } + if err := m.RowMatrix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPublic(dAtA[iNdEx:]) diff --git a/internal/public.proto b/internal/public.proto index 60bb18b74..6d6a56d70 100644 --- a/internal/public.proto +++ b/internal/public.proto @@ -9,6 +9,10 @@ message Row { bytes Roaring = 4; } +message RowMatrix { + repeated Row Rows = 1; +} + message SignedRow { Row Pos = 1; Row Neg = 2; @@ -161,6 +165,7 @@ message QueryResult { PairField PairField = 12; ExtractedIDMatrix ExtractedIDMatrix = 13; ExtractedTable ExtractedTable = 14; + RowMatrix RowMatrix = 15; } message ImportRequest { diff --git a/pql/ast.go b/pql/ast.go index 04ce5aed3..87a8b49d4 100644 --- a/pql/ast.go +++ b/pql/ast.go @@ -416,6 +416,15 @@ var callInfoByFunc = map[string]callInfo{ callType: PrecallGlobal, }, + "TopK": { + allowUnknown: false, + prototypes: map[string]interface{}{ + "_field": "", + "k": int64(0), + "filter": nil, + }, + }, + // things that take _field "TopN": allowUnderField, // special cases: diff --git a/pql/pql.peg b/pql/pql.peg index e413769e1..ec6241398 100644 --- a/pql/pql.peg +++ b/pql/pql.peg @@ -13,6 +13,7 @@ Call <- "Set" {p.startCall("Set")} open col comma args (comma timestamp)? close / "ClearRow" {p.startCall("ClearRow")} open arg close {p.endCall()} / "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()} / "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 61f765211..e761e9e60 100644 --- a/pql/pql.peg.go +++ b/pql/pql.peg.go @@ -8,7 +8,6 @@ import ( "os" "sort" "strconv" - "strings" ) const endSymbol rune = 1114112 @@ -75,9 +74,9 @@ const ( ruleAction19 ruleAction20 ruleAction21 - rulePegText ruleAction22 ruleAction23 + rulePegText ruleAction24 ruleAction25 ruleAction26 @@ -111,6 +110,8 @@ const ( ruleAction54 ruleAction55 ruleAction56 + ruleAction57 + ruleAction58 ) var rul3s = [...]string{ @@ -172,9 +173,9 @@ var rul3s = [...]string{ "Action19", "Action20", "Action21", - "PegText", "Action22", "Action23", + "PegText", "Action24", "Action25", "Action26", @@ -208,6 +209,8 @@ var rul3s = [...]string{ "Action54", "Action55", "Action56", + "Action57", + "Action58", } type token32 struct { @@ -324,7 +327,7 @@ type PQL struct { Buffer string buffer []rune - rules [94]func() bool + rules [96]func() bool parse func(rule ...int) error reset func() Pretty bool @@ -411,12 +414,6 @@ func (p *PQL) WriteSyntaxTree(w io.Writer) { p.tokens32.WriteSyntaxTree(w, p.Buffer) } -func (p *PQL) SprintSyntaxTree() string { - var bldr strings.Builder - p.WriteSyntaxTree(&bldr) - return bldr.String() -} - func (p *PQL) Execute() { buffer, _buffer, text, begin, end := p.Buffer, p.buffer, "", 0, 0 for _, token := range p.Tokens() { @@ -455,90 +452,94 @@ func (p *PQL) Execute() { case ruleAction13: p.endCall() case ruleAction14: - p.startCall("Rows") + p.startCall("TopK") case ruleAction15: p.endCall() case ruleAction16: - p.startCall("Range") + p.startCall("Rows") case ruleAction17: - p.addField("from") + p.endCall() case ruleAction18: - p.addVal(text) + p.startCall("Range") case ruleAction19: - p.addField("to") + p.addField("from") case ruleAction20: p.addVal(text) case ruleAction21: - p.endCall() + p.addField("to") case ruleAction22: - p.startCall(text) + p.addVal(text) case ruleAction23: p.endCall() case ruleAction24: - p.addBTWN() + p.startCall(text) case ruleAction25: - p.addLTE() + p.endCall() case ruleAction26: - p.addGTE() + p.addBTWN() case ruleAction27: - p.addEQ() + p.addLTE() case ruleAction28: - p.addNEQ() + p.addGTE() case ruleAction29: - p.addLT() + p.addEQ() case ruleAction30: - p.addGT() + p.addNEQ() case ruleAction31: - p.startConditional() + p.addLT() case ruleAction32: - p.endConditional() + p.addGT() case ruleAction33: - p.condAdd(text) + p.startConditional() case ruleAction34: - p.condAdd(text) + p.endConditional() case ruleAction35: p.condAdd(text) case ruleAction36: - p.startList() + p.condAdd(text) case ruleAction37: - p.endList() + p.condAdd(text) case ruleAction38: - p.addVal(nil) + p.startList() case ruleAction39: - p.addVal(true) + p.endList() case ruleAction40: - p.addVal(false) + p.addVal(nil) case ruleAction41: - p.addVal(text) + p.addVal(true) case ruleAction42: - p.addNumVal(text) + p.addVal(false) case ruleAction43: - p.startCall(text) + p.addVal(text) case ruleAction44: - p.addVal(p.endCall()) + p.addNumVal(text) case ruleAction45: - p.addVal(text) + p.startCall(text) case ruleAction46: - p.addVal(text) + p.addVal(p.endCall()) case ruleAction47: p.addVal(text) case ruleAction48: - p.addField(text) + p.addVal(text) case ruleAction49: - p.addPosStr("_field", text) + p.addVal(text) case ruleAction50: - p.addPosNum("_col", text) + p.addField(text) case ruleAction51: - p.addPosStr("_col", text) + p.addPosStr("_field", text) case ruleAction52: - p.addPosStr("_col", text) + p.addPosNum("_col", text) case ruleAction53: - p.addPosNum("_row", text) + p.addPosStr("_col", text) case ruleAction54: - p.addPosStr("_row", text) + p.addPosStr("_col", text) case ruleAction55: - p.addPosStr("_row", text) + p.addPosNum("_row", text) case ruleAction56: + p.addPosStr("_row", text) + case ruleAction57: + p.addPosStr("_row", text) + case ruleAction58: p.addPosStr("_timestamp", text) } @@ -670,7 +671,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) / (('r' / 'R') ('o' / 'O') ('w' / 'W') ('s' / 'S') Action14 open posfield (comma allargs)? close Action15) / (('r' / 'R') ('a' / 'A') ('n' / 'N') ('g' / 'G') ('e' / 'E') Action16 open field eq value comma ('f' 'r' 'o' 'm' '=')? Action17 timestampfmt Action18 comma ('t' 'o' '=')? sp Action19 timestampfmt Action20 close Action21) / ( Action22 open allargs comma? close Action23))> */ + /* 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) / ( Action24 open allargs comma? close Action25))> */ func() bool { position5, tokenIndex5 := position, tokenIndex { @@ -752,7 +753,7 @@ func (p *PQL) Init(options ...func(*PQL) error) error { add(rulePegText, position19) } { - add(ruleAction56, position) + add(ruleAction58, position) } add(ruletimestamp, position18) } @@ -959,7 +960,7 @@ func (p *PQL) Init(options ...func(*PQL) error) error { add(rulePegText, position49) } { - add(ruleAction53, position) + add(ruleAction55, position) } goto l47 l48: @@ -980,7 +981,7 @@ func (p *PQL) Init(options ...func(*PQL) error) error { add(rulePegText, position52) } { - add(ruleAction54, position) + add(ruleAction56, position) } goto l47 l51: @@ -1001,7 +1002,7 @@ func (p *PQL) Init(options ...func(*PQL) error) error { add(rulePegText, position54) } { - add(ruleAction55, position) + add(ruleAction57, position) } } l47: @@ -1685,14 +1686,14 @@ func (p *PQL) Init(options ...func(*PQL) error) error { position, tokenIndex = position7, tokenIndex7 { position147, tokenIndex147 := position, tokenIndex - if buffer[position] != rune('r') { + if buffer[position] != rune('t') { goto l148 } position++ goto l147 l148: position, tokenIndex = position147, tokenIndex147 - if buffer[position] != rune('R') { + if buffer[position] != rune('T') { goto l146 } position++ @@ -1715,14 +1716,14 @@ func (p *PQL) Init(options ...func(*PQL) error) error { l149: { position151, tokenIndex151 := position, tokenIndex - if buffer[position] != rune('w') { + if buffer[position] != rune('p') { goto l152 } position++ goto l151 l152: position, tokenIndex = position151, tokenIndex151 - if buffer[position] != rune('W') { + if buffer[position] != rune('P') { goto l146 } position++ @@ -1730,14 +1731,14 @@ func (p *PQL) Init(options ...func(*PQL) error) error { l151: { position153, tokenIndex153 := position, tokenIndex - if buffer[position] != rune('s') { + if buffer[position] != rune('k') { goto l154 } position++ goto l153 l154: position, tokenIndex = position153, tokenIndex153 - if buffer[position] != rune('S') { + if buffer[position] != rune('K') { goto l146 } position++ @@ -1791,14 +1792,14 @@ func (p *PQL) Init(options ...func(*PQL) error) error { l160: { position162, tokenIndex162 := position, tokenIndex - if buffer[position] != rune('a') { + if buffer[position] != rune('o') { goto l163 } position++ goto l162 l163: position, tokenIndex = position162, tokenIndex162 - if buffer[position] != rune('A') { + if buffer[position] != rune('O') { goto l159 } position++ @@ -1806,14 +1807,14 @@ func (p *PQL) Init(options ...func(*PQL) error) error { l162: { position164, tokenIndex164 := position, tokenIndex - if buffer[position] != rune('n') { + if buffer[position] != rune('w') { goto l165 } position++ goto l164 l165: position, tokenIndex = position164, tokenIndex164 - if buffer[position] != rune('N') { + if buffer[position] != rune('W') { goto l159 } position++ @@ -1821,141 +1822,232 @@ func (p *PQL) Init(options ...func(*PQL) error) error { l164: { position166, tokenIndex166 := position, tokenIndex - if buffer[position] != rune('g') { + if buffer[position] != rune('s') { goto l167 } position++ goto l166 l167: position, tokenIndex = position166, tokenIndex166 - if buffer[position] != rune('G') { + if buffer[position] != rune('S') { 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: { add(ruleAction16, position) } if !_rules[ruleopen]() { goto l159 } - if !_rules[rulefield]() { - goto l159 - } - if !_rules[ruleeq]() { - goto l159 - } - if !_rules[rulevalue]() { - goto l159 - } - if !_rules[rulecomma]() { + if !_rules[ruleposfield]() { goto l159 } { - position171, tokenIndex171 := position, tokenIndex - if buffer[position] != rune('f') { - goto l171 + position169, tokenIndex169 := position, tokenIndex + if !_rules[rulecomma]() { + goto l169 } - position++ - if buffer[position] != rune('r') { - goto l171 + if !_rules[ruleallargs]() { + goto l169 } - position++ - if buffer[position] != rune('o') { - goto l171 - } - position++ - if buffer[position] != rune('m') { - goto l171 - } - position++ - if buffer[position] != rune('=') { - goto l171 - } - position++ - goto l172 - l171: - position, tokenIndex = position171, tokenIndex171 - } - l172: - { - add(ruleAction17, position) - } - if !_rules[ruletimestampfmt]() { - goto l159 - } - { - add(ruleAction18, position) - } - if !_rules[rulecomma]() { - goto l159 - } - { - position175, tokenIndex175 := position, tokenIndex - if buffer[position] != rune('t') { - goto l175 - } - position++ - if buffer[position] != rune('o') { - goto l175 - } - position++ - if buffer[position] != rune('=') { - goto l175 - } - position++ - goto l176 - l175: - position, tokenIndex = position175, tokenIndex175 - } - l176: - if !_rules[rulesp]() { - goto l159 - } - { - add(ruleAction19, position) - } - if !_rules[ruletimestampfmt]() { - goto l159 - } - { - add(ruleAction20, position) + goto l170 + l169: + position, tokenIndex = position169, tokenIndex169 } + l170: if !_rules[ruleclose]() { goto l159 } { - add(ruleAction21, position) + add(ruleAction17, position) } goto l7 l159: position, tokenIndex = position7, tokenIndex7 { - position180 := position - if !_rules[ruleIDENT]() { - goto l5 + position173, tokenIndex173 := position, tokenIndex + if buffer[position] != rune('r') { + goto l174 } - add(rulePegText, position180) + position++ + goto l173 + l174: + position, tokenIndex = position173, tokenIndex173 + if buffer[position] != rune('R') { + goto l172 + } + position++ + } + l173: + { + position175, tokenIndex175 := position, tokenIndex + if buffer[position] != rune('a') { + goto l176 + } + position++ + goto l175 + l176: + position, tokenIndex = position175, tokenIndex175 + if buffer[position] != rune('A') { + goto l172 + } + position++ + } + l175: + { + position177, tokenIndex177 := position, tokenIndex + if buffer[position] != rune('n') { + goto l178 + } + position++ + goto l177 + l178: + position, tokenIndex = position177, tokenIndex177 + if buffer[position] != rune('N') { + goto l172 + } + position++ + } + l177: + { + position179, tokenIndex179 := position, tokenIndex + if buffer[position] != rune('g') { + goto l180 + } + position++ + goto l179 + l180: + position, tokenIndex = position179, tokenIndex179 + if buffer[position] != rune('G') { + goto l172 + } + 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: + { + add(ruleAction18, position) + } + if !_rules[ruleopen]() { + goto l172 + } + if !_rules[rulefield]() { + goto l172 + } + if !_rules[ruleeq]() { + goto l172 + } + if !_rules[rulevalue]() { + goto l172 + } + if !_rules[rulecomma]() { + goto l172 + } + { + position184, tokenIndex184 := position, tokenIndex + if buffer[position] != rune('f') { + goto l184 + } + position++ + if buffer[position] != rune('r') { + goto l184 + } + 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 + } + l185: + { + add(ruleAction19, position) + } + if !_rules[ruletimestampfmt]() { + goto l172 + } + { + add(ruleAction20, position) + } + if !_rules[rulecomma]() { + goto l172 + } + { + position188, tokenIndex188 := position, tokenIndex + if buffer[position] != rune('t') { + goto l188 + } + position++ + if buffer[position] != rune('o') { + goto l188 + } + position++ + if buffer[position] != rune('=') { + goto l188 + } + position++ + goto l189 + l188: + position, tokenIndex = position188, tokenIndex188 + } + l189: + if !_rules[rulesp]() { + goto l172 + } + { + add(ruleAction21, position) + } + if !_rules[ruletimestampfmt]() { + goto l172 } { add(ruleAction22, position) } + if !_rules[ruleclose]() { + goto l172 + } + { + add(ruleAction23, position) + } + goto l7 + l172: + position, tokenIndex = position7, tokenIndex7 + { + position193 := position + if !_rules[ruleIDENT]() { + goto l5 + } + add(rulePegText, position193) + } + { + add(ruleAction24, position) + } if !_rules[ruleopen]() { goto l5 } @@ -1963,20 +2055,20 @@ func (p *PQL) Init(options ...func(*PQL) error) error { goto l5 } { - position182, tokenIndex182 := position, tokenIndex + position195, tokenIndex195 := position, tokenIndex if !_rules[rulecomma]() { - goto l182 + goto l195 } - goto l183 - l182: - position, tokenIndex = position182, tokenIndex182 + goto l196 + l195: + position, tokenIndex = position195, tokenIndex195 } - l183: + l196: if !_rules[ruleclose]() { goto l5 } { - add(ruleAction23, position) + add(ruleAction25, position) } } l7: @@ -1988,1415 +2080,1415 @@ func (p *PQL) Init(options ...func(*PQL) error) error { return false }, /* 2 allargs <- <((Call (comma Call)* (comma args)?) / args / sp)> */ - func() bool { - position185, tokenIndex185 := position, tokenIndex - { - position186 := position - { - position187, tokenIndex187 := position, tokenIndex - if !_rules[ruleCall]() { - goto l188 - } - l189: - { - position190, tokenIndex190 := position, tokenIndex - if !_rules[rulecomma]() { - goto l190 - } - if !_rules[ruleCall]() { - goto l190 - } - goto l189 - l190: - position, tokenIndex = position190, tokenIndex190 - } - { - position191, tokenIndex191 := position, tokenIndex - if !_rules[rulecomma]() { - goto l191 - } - if !_rules[ruleargs]() { - goto l191 - } - goto l192 - l191: - position, tokenIndex = position191, tokenIndex191 - } - l192: - goto l187 - l188: - position, tokenIndex = position187, tokenIndex187 - if !_rules[ruleargs]() { - goto l193 - } - goto l187 - l193: - position, tokenIndex = position187, tokenIndex187 - if !_rules[rulesp]() { - goto l185 - } - } - l187: - add(ruleallargs, position186) - } - return true - l185: - position, tokenIndex = position185, tokenIndex185 - return false - }, - /* 3 args <- <(arg (comma args)? sp)> */ - func() bool { - position194, tokenIndex194 := position, tokenIndex - { - position195 := position - if !_rules[rulearg]() { - goto l194 - } - { - position196, tokenIndex196 := position, tokenIndex - if !_rules[rulecomma]() { - goto l196 - } - if !_rules[ruleargs]() { - goto l196 - } - goto l197 - l196: - position, tokenIndex = position196, tokenIndex196 - } - l197: - if !_rules[rulesp]() { - goto l194 - } - add(ruleargs, position195) - } - return true - l194: - position, tokenIndex = position194, tokenIndex194 - return false - }, - /* 4 arg <- <((field eq value) / (field sp COND sp value) / conditional)> */ func() bool { position198, tokenIndex198 := position, tokenIndex { position199 := position { position200, tokenIndex200 := position, tokenIndex - if !_rules[rulefield]() { + if !_rules[ruleCall]() { goto l201 } - if !_rules[ruleeq]() { - goto l201 + l202: + { + position203, tokenIndex203 := position, tokenIndex + if !_rules[rulecomma]() { + goto l203 + } + if !_rules[ruleCall]() { + goto l203 + } + goto l202 + l203: + position, tokenIndex = position203, tokenIndex203 } - if !_rules[rulevalue]() { - goto l201 + { + position204, tokenIndex204 := position, tokenIndex + if !_rules[rulecomma]() { + goto l204 + } + if !_rules[ruleargs]() { + goto l204 + } + goto l205 + l204: + position, tokenIndex = position204, tokenIndex204 } + l205: goto l200 l201: position, tokenIndex = position200, tokenIndex200 - if !_rules[rulefield]() { - goto l202 - } - if !_rules[rulesp]() { - goto l202 - } - { - position203 := position - { - position204, tokenIndex204 := position, tokenIndex - if buffer[position] != rune('>') { - goto l205 - } - position++ - if buffer[position] != rune('<') { - goto l205 - } - position++ - { - add(ruleAction24, position) - } - goto l204 - l205: - position, tokenIndex = position204, tokenIndex204 - if buffer[position] != rune('<') { - goto l207 - } - position++ - if buffer[position] != rune('=') { - goto l207 - } - position++ - { - add(ruleAction25, position) - } - goto l204 - l207: - position, tokenIndex = position204, tokenIndex204 - if buffer[position] != rune('>') { - goto l209 - } - position++ - if buffer[position] != rune('=') { - goto l209 - } - position++ - { - add(ruleAction26, position) - } - goto l204 - l209: - position, tokenIndex = position204, tokenIndex204 - if buffer[position] != rune('=') { - goto l211 - } - position++ - if buffer[position] != rune('=') { - goto l211 - } - position++ - { - add(ruleAction27, position) - } - goto l204 - l211: - position, tokenIndex = position204, tokenIndex204 - if buffer[position] != rune('!') { - goto l213 - } - position++ - if buffer[position] != rune('=') { - goto l213 - } - position++ - { - add(ruleAction28, position) - } - goto l204 - l213: - position, tokenIndex = position204, tokenIndex204 - if buffer[position] != rune('<') { - goto l215 - } - position++ - { - add(ruleAction29, position) - } - goto l204 - l215: - position, tokenIndex = position204, tokenIndex204 - if buffer[position] != rune('>') { - goto l202 - } - position++ - { - add(ruleAction30, position) - } - } - l204: - add(ruleCOND, position203) - } - if !_rules[rulesp]() { - goto l202 - } - if !_rules[rulevalue]() { - goto l202 + if !_rules[ruleargs]() { + goto l206 } goto l200 - l202: + l206: position, tokenIndex = position200, tokenIndex200 - { - position218 := position - { - add(ruleAction31, position) - } - if !_rules[rulecondint]() { - goto l198 - } - if !_rules[rulecondLT]() { - goto l198 - } - { - position220 := position - { - position221 := position - if !_rules[rulefieldExpr]() { - goto l198 - } - add(rulePegText, position221) - } - if !_rules[rulesp]() { - goto l198 - } - { - add(ruleAction35, position) - } - add(rulecondfield, position220) - } - if !_rules[rulecondLT]() { - goto l198 - } - if !_rules[rulecondint]() { - goto l198 - } - { - add(ruleAction32, position) - } - add(ruleconditional, position218) + if !_rules[rulesp]() { + goto l198 } } l200: - add(rulearg, position199) + add(ruleallargs, position199) } return true l198: position, tokenIndex = position198, tokenIndex198 return false }, - /* 5 COND <- <(('>' '<' Action24) / ('<' '=' Action25) / ('>' '=' Action26) / ('=' '=' Action27) / ('!' '=' Action28) / ('<' Action29) / ('>' Action30))> */ - nil, - /* 6 conditional <- <(Action31 condint condLT condfield condLT condint Action32)> */ - nil, - /* 7 condint <- <( sp Action33)> */ + /* 3 args <- <(arg (comma args)? sp)> */ func() bool { - position226, tokenIndex226 := position, tokenIndex + position207, tokenIndex207 := position, tokenIndex { - position227 := position + position208 := position + if !_rules[rulearg]() { + goto l207 + } { - position228 := position - if !_rules[ruledecimal]() { - goto l226 + position209, tokenIndex209 := position, tokenIndex + if !_rules[rulecomma]() { + goto l209 } - add(rulePegText, position228) + if !_rules[ruleargs]() { + goto l209 + } + goto l210 + l209: + position, tokenIndex = position209, tokenIndex209 } + l210: if !_rules[rulesp]() { - goto l226 + goto l207 } - { - add(ruleAction33, position) - } - add(rulecondint, position227) + add(ruleargs, position208) } return true - l226: - position, tokenIndex = position226, tokenIndex226 + l207: + position, tokenIndex = position207, tokenIndex207 return false }, - /* 8 condLT <- <(<(('<' '=') / '<')> sp Action34)> */ + /* 4 arg <- <((field eq value) / (field sp COND sp value) / conditional)> */ func() bool { - position230, tokenIndex230 := position, tokenIndex + position211, tokenIndex211 := position, tokenIndex { - position231 := position + position212 := position { - position232 := position + position213, tokenIndex213 := position, tokenIndex + if !_rules[rulefield]() { + goto l214 + } + if !_rules[ruleeq]() { + goto l214 + } + if !_rules[rulevalue]() { + goto l214 + } + goto l213 + l214: + position, tokenIndex = position213, tokenIndex213 + if !_rules[rulefield]() { + goto l215 + } + if !_rules[rulesp]() { + goto l215 + } { - position233, tokenIndex233 := position, tokenIndex + position216 := position + { + position217, tokenIndex217 := position, tokenIndex + if buffer[position] != rune('>') { + goto l218 + } + 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 + } + position++ + { + add(ruleAction28, position) + } + goto l217 + l222: + position, tokenIndex = position217, tokenIndex217 + if buffer[position] != rune('=') { + goto l224 + } + position++ + if buffer[position] != rune('=') { + goto l224 + } + position++ + { + add(ruleAction29, position) + } + goto l217 + l224: + position, tokenIndex = position217, tokenIndex217 + if buffer[position] != rune('!') { + goto l226 + } + position++ + if buffer[position] != rune('=') { + goto l226 + } + position++ + { + add(ruleAction30, position) + } + goto l217 + l226: + position, tokenIndex = position217, tokenIndex217 + if buffer[position] != rune('<') { + goto l228 + } + position++ + { + add(ruleAction31, position) + } + goto l217 + l228: + position, tokenIndex = position217, tokenIndex217 + if buffer[position] != rune('>') { + goto l215 + } + position++ + { + add(ruleAction32, position) + } + } + l217: + add(ruleCOND, position216) + } + if !_rules[rulesp]() { + goto l215 + } + if !_rules[rulevalue]() { + goto l215 + } + goto l213 + l215: + position, tokenIndex = position213, tokenIndex213 + { + position231 := position + { + add(ruleAction33, position) + } + if !_rules[rulecondint]() { + goto l211 + } + if !_rules[rulecondLT]() { + goto l211 + } + { + position233 := position + { + position234 := position + if !_rules[rulefieldExpr]() { + goto l211 + } + add(rulePegText, position234) + } + if !_rules[rulesp]() { + goto l211 + } + { + add(ruleAction37, position) + } + add(rulecondfield, position233) + } + if !_rules[rulecondLT]() { + goto l211 + } + if !_rules[rulecondint]() { + goto l211 + } + { + add(ruleAction34, position) + } + add(ruleconditional, position231) + } + } + l213: + add(rulearg, position212) + } + return true + l211: + position, tokenIndex = position211, tokenIndex211 + return false + }, + /* 5 COND <- <(('>' '<' Action26) / ('<' '=' Action27) / ('>' '=' Action28) / ('=' '=' Action29) / ('!' '=' Action30) / ('<' Action31) / ('>' Action32))> */ + nil, + /* 6 conditional <- <(Action33 condint condLT condfield condLT condint Action34)> */ + nil, + /* 7 condint <- <( sp Action35)> */ + func() bool { + position239, tokenIndex239 := position, tokenIndex + { + position240 := position + { + position241 := position + if !_rules[ruledecimal]() { + goto l239 + } + add(rulePegText, position241) + } + if !_rules[rulesp]() { + goto l239 + } + { + add(ruleAction35, position) + } + add(rulecondint, position240) + } + return true + l239: + position, tokenIndex = position239, tokenIndex239 + return false + }, + /* 8 condLT <- <(<(('<' '=') / '<')> sp Action36)> */ + func() bool { + position243, tokenIndex243 := position, tokenIndex + { + position244 := position + { + position245 := position + { + position246, tokenIndex246 := position, tokenIndex if buffer[position] != rune('<') { - goto l234 + goto l247 } position++ if buffer[position] != rune('=') { - goto l234 + goto l247 } position++ - goto l233 - l234: - position, tokenIndex = position233, tokenIndex233 + goto l246 + l247: + position, tokenIndex = position246, tokenIndex246 if buffer[position] != rune('<') { - goto l230 + goto l243 } position++ } - l233: - add(rulePegText, position232) + l246: + add(rulePegText, position245) } if !_rules[rulesp]() { - goto l230 + goto l243 } { - add(ruleAction34, position) + add(ruleAction36, position) } - add(rulecondLT, position231) + add(rulecondLT, position244) } return true - l230: - position, tokenIndex = position230, tokenIndex230 + l243: + position, tokenIndex = position243, tokenIndex243 return false }, - /* 9 condfield <- <( sp Action35)> */ + /* 9 condfield <- <( sp Action37)> */ nil, - /* 10 value <- <(item / (lbrack Action36 items rbrack Action37))> */ + /* 10 value <- <(item / (lbrack Action38 items rbrack Action39))> */ func() bool { - position237, tokenIndex237 := position, tokenIndex + position250, tokenIndex250 := position, tokenIndex { - position238 := position + position251 := position { - position239, tokenIndex239 := position, tokenIndex + position252, tokenIndex252 := position, tokenIndex if !_rules[ruleitem]() { - goto l240 + goto l253 } - goto l239 - l240: - position, tokenIndex = position239, tokenIndex239 + goto l252 + l253: + position, tokenIndex = position252, tokenIndex252 { - position241 := position + position254 := position if buffer[position] != rune('[') { - goto l237 + goto l250 } position++ if !_rules[rulesp]() { - goto l237 + goto l250 } - add(rulelbrack, position241) - } - { - add(ruleAction36, position) - } - if !_rules[ruleitems]() { - goto l237 - } - { - position243 := position - if !_rules[rulesp]() { - goto l237 - } - if buffer[position] != rune(']') { - goto l237 - } - position++ - if !_rules[rulesp]() { - goto l237 - } - add(rulerbrack, position243) - } - { - add(ruleAction37, position) - } - } - l239: - add(rulevalue, position238) - } - return true - l237: - position, tokenIndex = position237, tokenIndex237 - return false - }, - /* 11 items <- <(item (comma items)?)> */ - func() bool { - position245, tokenIndex245 := position, tokenIndex - { - position246 := position - if !_rules[ruleitem]() { - goto l245 - } - { - position247, tokenIndex247 := position, tokenIndex - if !_rules[rulecomma]() { - goto l247 - } - if !_rules[ruleitems]() { - goto l247 - } - goto l248 - l247: - position, tokenIndex = position247, tokenIndex247 - } - l248: - add(ruleitems, position246) - } - return true - l245: - position, tokenIndex = position245, tokenIndex245 - return false - }, - /* 12 item <- <(('n' 'u' 'l' 'l' &(comma / close) Action38) / ('t' 'r' 'u' 'e' &(comma / close) Action39) / ('f' 'a' 'l' 's' 'e' &(comma / close) Action40) / (timestampfmt Action41) / ( Action42) / ( Action43 open allargs comma? close Action44) / (<([a-z] / [A-Z] / [0-9] / '-' / '_' / ':')+> Action45) / (<('"' doublequotedstring '"')> Action46) / (<('\'' singlequotedstring '\'')> Action47))> */ - func() bool { - position249, tokenIndex249 := position, tokenIndex - { - position250 := position - { - position251, tokenIndex251 := position, tokenIndex - if buffer[position] != rune('n') { - goto l252 - } - position++ - if buffer[position] != rune('u') { - goto l252 - } - position++ - if buffer[position] != rune('l') { - goto l252 - } - position++ - if buffer[position] != rune('l') { - goto l252 - } - position++ - { - position253, tokenIndex253 := position, tokenIndex - { - position254, tokenIndex254 := position, tokenIndex - if !_rules[rulecomma]() { - goto l255 - } - goto l254 - l255: - position, tokenIndex = position254, tokenIndex254 - if !_rules[ruleclose]() { - goto l252 - } - } - l254: - position, tokenIndex = position253, tokenIndex253 + add(rulelbrack, position254) } { add(ruleAction38, position) } - goto l251 - l252: - position, tokenIndex = position251, tokenIndex251 - if buffer[position] != rune('t') { - goto l257 + if !_rules[ruleitems]() { + goto l250 } - position++ - if buffer[position] != rune('r') { - goto l257 - } - position++ - if buffer[position] != rune('u') { - goto l257 - } - position++ - if buffer[position] != rune('e') { - goto l257 - } - position++ { - position258, tokenIndex258 := position, tokenIndex - { - position259, tokenIndex259 := position, tokenIndex - if !_rules[rulecomma]() { - goto l260 - } - goto l259 - l260: - position, tokenIndex = position259, tokenIndex259 - if !_rules[ruleclose]() { - goto l257 - } + position256 := position + if !_rules[rulesp]() { + goto l250 } - l259: - position, tokenIndex = position258, tokenIndex258 + if buffer[position] != rune(']') { + goto l250 + } + position++ + if !_rules[rulesp]() { + goto l250 + } + add(rulerbrack, position256) } { add(ruleAction39, position) } - goto l251 - l257: - position, tokenIndex = position251, tokenIndex251 - if buffer[position] != rune('f') { - goto l262 + } + 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) / ( Action44) / ( 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('a') { - goto l262 + if buffer[position] != rune('u') { + goto l265 } position++ if buffer[position] != rune('l') { - goto l262 + goto l265 } position++ - if buffer[position] != rune('s') { - goto l262 - } - position++ - if buffer[position] != rune('e') { - goto l262 + if buffer[position] != rune('l') { + goto l265 } position++ { - position263, tokenIndex263 := position, tokenIndex + position266, tokenIndex266 := position, tokenIndex { - position264, tokenIndex264 := position, tokenIndex + position267, tokenIndex267 := position, tokenIndex if !_rules[rulecomma]() { + goto l268 + } + goto l267 + l268: + position, tokenIndex = position267, tokenIndex267 + if !_rules[ruleclose]() { goto l265 } - goto l264 - l265: - position, tokenIndex = position264, tokenIndex264 - if !_rules[ruleclose]() { - goto l262 - } } - l264: - position, tokenIndex = position263, tokenIndex263 + l267: + position, tokenIndex = position266, tokenIndex266 } { add(ruleAction40, position) } - goto l251 - l262: - position, tokenIndex = position251, tokenIndex251 - if !_rules[ruletimestampfmt]() { - goto l267 + goto l264 + l265: + position, tokenIndex = position264, tokenIndex264 + if buffer[position] != rune('t') { + goto l270 + } + 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 + } + } + l272: + position, tokenIndex = position271, tokenIndex271 } { add(ruleAction41, position) } - goto l251 - l267: - position, tokenIndex = position251, tokenIndex251 + goto l264 + l270: + position, tokenIndex = position264, tokenIndex264 + if buffer[position] != rune('f') { + goto l275 + } + position++ + if buffer[position] != rune('a') { + goto l275 + } + position++ + if buffer[position] != rune('l') { + goto l275 + } + position++ + if buffer[position] != rune('s') { + goto l275 + } + position++ + if buffer[position] != rune('e') { + goto l275 + } + position++ { - position270 := position - if !_rules[ruledecimal]() { - goto l269 + position276, tokenIndex276 := position, tokenIndex + { + position277, tokenIndex277 := position, tokenIndex + if !_rules[rulecomma]() { + goto l278 + } + goto l277 + l278: + position, tokenIndex = position277, tokenIndex277 + if !_rules[ruleclose]() { + goto l275 + } } - add(rulePegText, position270) + l277: + position, tokenIndex = position276, tokenIndex276 } { add(ruleAction42, position) } - goto l251 - l269: - position, tokenIndex = position251, tokenIndex251 - { - position273 := position - if !_rules[ruleIDENT]() { - goto l272 - } - add(rulePegText, position273) + goto l264 + l275: + position, tokenIndex = position264, tokenIndex264 + if !_rules[ruletimestampfmt]() { + goto l280 } { add(ruleAction43, position) } - if !_rules[ruleopen]() { - goto l272 - } - if !_rules[ruleallargs]() { - goto l272 - } + goto l264 + l280: + position, tokenIndex = position264, tokenIndex264 { - position275, tokenIndex275 := position, tokenIndex - if !_rules[rulecomma]() { - goto l275 + position283 := position + if !_rules[ruledecimal]() { + goto l282 } - goto l276 - l275: - position, tokenIndex = position275, tokenIndex275 - } - l276: - if !_rules[ruleclose]() { - goto l272 + add(rulePegText, position283) } { add(ruleAction44, position) } - goto l251 - l272: - position, tokenIndex = position251, tokenIndex251 + goto l264 + l282: + position, tokenIndex = position264, tokenIndex264 { - position279 := position - { - position282, tokenIndex282 := position, tokenIndex - if c := buffer[position]; c < rune('a') || c > rune('z') { - goto l283 - } - position++ - goto l282 - l283: - position, tokenIndex = position282, tokenIndex282 - if c := buffer[position]; c < rune('A') || c > rune('Z') { - goto l284 - } - position++ - goto l282 - l284: - position, tokenIndex = position282, tokenIndex282 - if c := buffer[position]; c < rune('0') || c > rune('9') { - goto l285 - } - position++ - goto l282 - l285: - position, tokenIndex = position282, tokenIndex282 - if buffer[position] != rune('-') { - goto l286 - } - position++ - goto l282 - l286: - position, tokenIndex = position282, tokenIndex282 - if buffer[position] != rune('_') { - goto l287 - } - position++ - goto l282 - l287: - position, tokenIndex = position282, tokenIndex282 - if buffer[position] != rune(':') { - goto l278 - } - position++ + position286 := position + if !_rules[ruleIDENT]() { + goto l285 } - l282: - l280: - { - position281, tokenIndex281 := position, tokenIndex - { - position288, tokenIndex288 := position, tokenIndex - if c := buffer[position]; c < rune('a') || c > rune('z') { - goto l289 - } - position++ - goto l288 - l289: - position, tokenIndex = position288, tokenIndex288 - if c := buffer[position]; c < rune('A') || c > rune('Z') { - goto l290 - } - position++ - goto l288 - l290: - position, tokenIndex = position288, tokenIndex288 - if c := buffer[position]; c < rune('0') || c > rune('9') { - goto l291 - } - position++ - goto l288 - l291: - position, tokenIndex = position288, tokenIndex288 - if buffer[position] != rune('-') { - goto l292 - } - position++ - goto l288 - l292: - position, tokenIndex = position288, tokenIndex288 - if buffer[position] != rune('_') { - goto l293 - } - position++ - goto l288 - l293: - position, tokenIndex = position288, tokenIndex288 - if buffer[position] != rune(':') { - goto l281 - } - position++ - } - l288: - goto l280 - l281: - position, tokenIndex = position281, tokenIndex281 - } - add(rulePegText, position279) + add(rulePegText, position286) } { add(ruleAction45, position) } - goto l251 - l278: - position, tokenIndex = position251, tokenIndex251 + if !_rules[ruleopen]() { + goto l285 + } + if !_rules[ruleallargs]() { + goto l285 + } { - position296 := position - if buffer[position] != rune('"') { - goto l295 + position288, tokenIndex288 := position, tokenIndex + if !_rules[rulecomma]() { + goto l288 } - position++ - if !_rules[ruledoublequotedstring]() { - goto l295 - } - if buffer[position] != rune('"') { - goto l295 - } - position++ - add(rulePegText, position296) + goto l289 + l288: + position, tokenIndex = position288, tokenIndex288 + } + l289: + if !_rules[ruleclose]() { + goto l285 } { add(ruleAction46, position) } - goto l251 - l295: - position, tokenIndex = position251, tokenIndex251 + goto l264 + l285: + position, tokenIndex = position264, tokenIndex264 { - position298 := position - if buffer[position] != rune('\'') { - goto l249 + 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++ } - position++ - if !_rules[rulesinglequotedstring]() { - goto l249 + 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 } - if buffer[position] != rune('\'') { - goto l249 - } - position++ - add(rulePegText, position298) + add(rulePegText, position292) } { add(ruleAction47, position) } + goto l264 + l291: + position, tokenIndex = position264, tokenIndex264 + { + position309 := position + if buffer[position] != rune('"') { + goto l308 + } + position++ + if !_rules[ruledoublequotedstring]() { + goto l308 + } + if buffer[position] != rune('"') { + goto l308 + } + position++ + add(rulePegText, position309) + } + { + add(ruleAction48, position) + } + goto l264 + l308: + position, tokenIndex = position264, tokenIndex264 + { + position311 := position + if buffer[position] != rune('\'') { + goto l262 + } + position++ + if !_rules[rulesinglequotedstring]() { + goto l262 + } + if buffer[position] != rune('\'') { + goto l262 + } + position++ + add(rulePegText, position311) + } + { + add(ruleAction49, position) + } } - l251: - add(ruleitem, position250) + l264: + add(ruleitem, position263) } return true - l249: - position, tokenIndex = position249, tokenIndex249 + l262: + position, tokenIndex = position262, tokenIndex262 return false }, /* 13 doublequotedstring <- <(('\\' '"') / ('\\' '\\') / ('\\' 'n') / ('\\' 't') / (!('"' / '\\') .))*> */ func() bool { { - position301 := position - l302: + position314 := position + l315: { - position303, tokenIndex303 := position, tokenIndex + position316, tokenIndex316 := position, tokenIndex { - position304, tokenIndex304 := position, tokenIndex + position317, tokenIndex317 := position, tokenIndex if buffer[position] != rune('\\') { - goto l305 + goto l318 } position++ if buffer[position] != rune('"') { - goto l305 + goto l318 } position++ - goto l304 - l305: - position, tokenIndex = position304, tokenIndex304 + goto l317 + l318: + position, tokenIndex = position317, tokenIndex317 if buffer[position] != rune('\\') { - goto l306 + goto l319 } position++ if buffer[position] != rune('\\') { - goto l306 + goto l319 } position++ - goto l304 - l306: - position, tokenIndex = position304, tokenIndex304 + goto l317 + l319: + position, tokenIndex = position317, tokenIndex317 if buffer[position] != rune('\\') { - goto l307 + goto l320 } position++ if buffer[position] != rune('n') { - goto l307 + goto l320 } position++ - goto l304 - l307: - position, tokenIndex = position304, tokenIndex304 + goto l317 + l320: + position, tokenIndex = position317, tokenIndex317 if buffer[position] != rune('\\') { - goto l308 + goto l321 } position++ if buffer[position] != rune('t') { - goto l308 + goto l321 } position++ - goto l304 - l308: - position, tokenIndex = position304, tokenIndex304 + goto l317 + l321: + position, tokenIndex = position317, tokenIndex317 { - position309, tokenIndex309 := position, tokenIndex + position322, tokenIndex322 := position, tokenIndex { - position310, tokenIndex310 := position, tokenIndex + position323, tokenIndex323 := position, tokenIndex if buffer[position] != rune('"') { - goto l311 + goto l324 } position++ - goto l310 - l311: - position, tokenIndex = position310, tokenIndex310 + goto l323 + l324: + position, tokenIndex = position323, tokenIndex323 if buffer[position] != rune('\\') { - goto l309 + goto l322 } position++ } - l310: - goto l303 - l309: - position, tokenIndex = position309, tokenIndex309 + l323: + goto l316 + l322: + position, tokenIndex = position322, tokenIndex322 } if !matchDot() { - goto l303 + goto l316 } } - l304: - goto l302 - l303: - position, tokenIndex = position303, tokenIndex303 + l317: + goto l315 + l316: + position, tokenIndex = position316, tokenIndex316 } - add(ruledoublequotedstring, position301) + add(ruledoublequotedstring, position314) } return true }, /* 14 singlequotedstring <- <(('\\' '\'') / ('\\' '\\') / ('\\' 'n') / ('\\' 't') / (!('\'' / '\\') .))*> */ func() bool { { - position313 := position - l314: + position326 := position + l327: { - position315, tokenIndex315 := position, tokenIndex + position328, tokenIndex328 := position, tokenIndex { - position316, tokenIndex316 := position, tokenIndex + position329, tokenIndex329 := position, tokenIndex if buffer[position] != rune('\\') { - goto l317 + goto l330 } position++ if buffer[position] != rune('\'') { - goto l317 + goto l330 } position++ - goto l316 - l317: - position, tokenIndex = position316, tokenIndex316 + goto l329 + l330: + position, tokenIndex = position329, tokenIndex329 if buffer[position] != rune('\\') { - goto l318 + goto l331 } position++ if buffer[position] != rune('\\') { - goto l318 + goto l331 } position++ - goto l316 - l318: - position, tokenIndex = position316, tokenIndex316 + goto l329 + l331: + position, tokenIndex = position329, tokenIndex329 if buffer[position] != rune('\\') { - goto l319 + goto l332 } position++ if buffer[position] != rune('n') { - goto l319 + goto l332 } position++ - goto l316 - l319: - position, tokenIndex = position316, tokenIndex316 + goto l329 + l332: + position, tokenIndex = position329, tokenIndex329 if buffer[position] != rune('\\') { - goto l320 + goto l333 } position++ if buffer[position] != rune('t') { - goto l320 + goto l333 } position++ - goto l316 - l320: - position, tokenIndex = position316, tokenIndex316 + goto l329 + l333: + position, tokenIndex = position329, tokenIndex329 { - position321, tokenIndex321 := position, tokenIndex + position334, tokenIndex334 := position, tokenIndex { - position322, tokenIndex322 := position, tokenIndex + position335, tokenIndex335 := position, tokenIndex if buffer[position] != rune('\'') { - goto l323 + goto l336 } position++ - goto l322 - l323: - position, tokenIndex = position322, tokenIndex322 + goto l335 + l336: + position, tokenIndex = position335, tokenIndex335 if buffer[position] != rune('\\') { - goto l321 + goto l334 } position++ } - l322: - goto l315 - l321: - position, tokenIndex = position321, tokenIndex321 + l335: + goto l328 + l334: + position, tokenIndex = position334, tokenIndex334 } if !matchDot() { - goto l315 + goto l328 } } - l316: - goto l314 - l315: - position, tokenIndex = position315, tokenIndex315 + l329: + goto l327 + l328: + position, tokenIndex = position328, tokenIndex328 } - add(rulesinglequotedstring, position313) + add(rulesinglequotedstring, position326) } return true }, /* 15 fieldExpr <- <(([a-z] / [A-Z] / '_') ([a-z] / [A-Z] / [0-9] / '_' / '-')*)> */ func() bool { - position324, tokenIndex324 := position, tokenIndex + position337, tokenIndex337 := position, tokenIndex { - position325 := position + position338 := position { - position326, tokenIndex326 := position, tokenIndex + position339, tokenIndex339 := position, tokenIndex if c := buffer[position]; c < rune('a') || c > rune('z') { - goto l327 + goto l340 } position++ - goto l326 - l327: - position, tokenIndex = position326, tokenIndex326 + goto l339 + l340: + position, tokenIndex = position339, tokenIndex339 if c := buffer[position]; c < rune('A') || c > rune('Z') { - goto l328 + goto l341 } position++ - goto l326 - l328: - position, tokenIndex = position326, tokenIndex326 + goto l339 + l341: + position, tokenIndex = position339, tokenIndex339 if buffer[position] != rune('_') { - goto l324 + goto l337 } position++ } - l326: - l329: + l339: + l342: { - position330, tokenIndex330 := position, tokenIndex + position343, tokenIndex343 := position, tokenIndex { - position331, tokenIndex331 := position, tokenIndex + position344, tokenIndex344 := position, tokenIndex if c := buffer[position]; c < rune('a') || c > rune('z') { - goto l332 + goto l345 } position++ - goto l331 - l332: - position, tokenIndex = position331, tokenIndex331 + goto l344 + l345: + position, tokenIndex = position344, tokenIndex344 if c := buffer[position]; c < rune('A') || c > rune('Z') { - goto l333 + goto l346 } position++ - goto l331 - l333: - position, tokenIndex = position331, tokenIndex331 + goto l344 + l346: + position, tokenIndex = position344, tokenIndex344 if c := buffer[position]; c < rune('0') || c > rune('9') { - goto l334 + goto l347 } position++ - goto l331 - l334: - position, tokenIndex = position331, tokenIndex331 + goto l344 + l347: + position, tokenIndex = position344, tokenIndex344 if buffer[position] != rune('_') { - goto l335 + goto l348 } position++ - goto l331 - l335: - position, tokenIndex = position331, tokenIndex331 + goto l344 + l348: + position, tokenIndex = position344, tokenIndex344 if buffer[position] != rune('-') { - goto l330 + goto l343 } position++ } - l331: - goto l329 - l330: - position, tokenIndex = position330, tokenIndex330 + l344: + goto l342 + l343: + position, tokenIndex = position343, tokenIndex343 } - add(rulefieldExpr, position325) + add(rulefieldExpr, position338) } return true - l324: - position, tokenIndex = position324, tokenIndex324 + l337: + position, tokenIndex = position337, tokenIndex337 return false }, - /* 16 field <- <(<(fieldExpr / reserved)> Action48)> */ + /* 16 field <- <(<(fieldExpr / reserved)> Action50)> */ func() bool { - position336, tokenIndex336 := position, tokenIndex + position349, tokenIndex349 := position, tokenIndex { - position337 := position + position350 := position { - position338 := position + position351 := position { - position339, tokenIndex339 := position, tokenIndex + position352, tokenIndex352 := position, tokenIndex if !_rules[rulefieldExpr]() { - goto l340 + goto l353 } - goto l339 - l340: - position, tokenIndex = position339, tokenIndex339 + goto l352 + l353: + position, tokenIndex = position352, tokenIndex352 { - position341 := position + position354 := position { - position342, tokenIndex342 := position, tokenIndex + position355, tokenIndex355 := position, tokenIndex if buffer[position] != rune('_') { - goto l343 + goto l356 } position++ if buffer[position] != rune('r') { - goto l343 + goto l356 } position++ if buffer[position] != rune('o') { - goto l343 + goto l356 } position++ if buffer[position] != rune('w') { - goto l343 + goto l356 } position++ - goto l342 - l343: - position, tokenIndex = position342, tokenIndex342 + goto l355 + l356: + position, tokenIndex = position355, tokenIndex355 if buffer[position] != rune('_') { - goto l344 + goto l357 } position++ if buffer[position] != rune('c') { - goto l344 + goto l357 } position++ if buffer[position] != rune('o') { - goto l344 + goto l357 } position++ if buffer[position] != rune('l') { - goto l344 + goto l357 } position++ - goto l342 - l344: - position, tokenIndex = position342, tokenIndex342 + goto l355 + l357: + position, tokenIndex = position355, tokenIndex355 if buffer[position] != rune('_') { - goto l345 + goto l358 } position++ if buffer[position] != rune('s') { - goto l345 + goto l358 } position++ if buffer[position] != rune('t') { - goto l345 + goto l358 } position++ if buffer[position] != rune('a') { - goto l345 + goto l358 } position++ if buffer[position] != rune('r') { - goto l345 + goto l358 } position++ if buffer[position] != rune('t') { - goto l345 + goto l358 } position++ - goto l342 - l345: - position, tokenIndex = position342, tokenIndex342 + goto l355 + l358: + position, tokenIndex = position355, tokenIndex355 if buffer[position] != rune('_') { - goto l346 + goto l359 } position++ if buffer[position] != rune('e') { - goto l346 + goto l359 } position++ if buffer[position] != rune('n') { - goto l346 + goto l359 } position++ if buffer[position] != rune('d') { - goto l346 + goto l359 } position++ - goto l342 - l346: - position, tokenIndex = position342, tokenIndex342 + goto l355 + l359: + position, tokenIndex = position355, tokenIndex355 if buffer[position] != rune('_') { - goto l347 + goto l360 } position++ if buffer[position] != rune('t') { - goto l347 + goto l360 } position++ if buffer[position] != rune('i') { - goto l347 + goto l360 } position++ if buffer[position] != rune('m') { - goto l347 + goto l360 } position++ if buffer[position] != rune('e') { - goto l347 + goto l360 } position++ if buffer[position] != rune('s') { - goto l347 + goto l360 } position++ if buffer[position] != rune('t') { - goto l347 + goto l360 } position++ if buffer[position] != rune('a') { - goto l347 + goto l360 } position++ if buffer[position] != rune('m') { - goto l347 + goto l360 } position++ if buffer[position] != rune('p') { - goto l347 + goto l360 } position++ - goto l342 - l347: - position, tokenIndex = position342, tokenIndex342 + goto l355 + l360: + position, tokenIndex = position355, tokenIndex355 if buffer[position] != rune('_') { - goto l336 + goto l349 } position++ if buffer[position] != rune('f') { - goto l336 + goto l349 } position++ if buffer[position] != rune('i') { - goto l336 + goto l349 } position++ if buffer[position] != rune('e') { - goto l336 + goto l349 } position++ if buffer[position] != rune('l') { - goto l336 + goto l349 } position++ if buffer[position] != rune('d') { - goto l336 + goto l349 } position++ } - l342: - add(rulereserved, position341) + l355: + add(rulereserved, position354) } } - l339: - add(rulePegText, position338) + l352: + add(rulePegText, position351) } { - add(ruleAction48, position) + add(ruleAction50, position) } - add(rulefield, position337) + add(rulefield, position350) } return true - l336: - position, tokenIndex = position336, tokenIndex336 + l349: + position, tokenIndex = position349, tokenIndex349 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 <- <( Action49)> */ + /* 18 posfield <- <( Action51)> */ func() bool { - position350, tokenIndex350 := position, tokenIndex + position363, tokenIndex363 := position, tokenIndex { - position351 := position + position364 := position { - position352 := position + position365 := position if !_rules[rulefieldExpr]() { - goto l350 + goto l363 } - add(rulePegText, position352) + add(rulePegText, position365) } { - add(ruleAction49, position) + add(ruleAction51, position) } - add(ruleposfield, position351) + add(ruleposfield, position364) } return true - l350: - position, tokenIndex = position350, tokenIndex350 + l363: + position, tokenIndex = position363, tokenIndex363 return false }, - /* 19 col <- <(( Action50) / (<('\'' singlequotedstring '\'')> Action51) / (<('"' doublequotedstring '"')> Action52))> */ + /* 19 col <- <(( Action52) / (<('\'' singlequotedstring '\'')> Action53) / (<('"' doublequotedstring '"')> Action54))> */ func() bool { - position354, tokenIndex354 := position, tokenIndex + position367, tokenIndex367 := position, tokenIndex { - position355 := position + position368 := position { - position356, tokenIndex356 := position, tokenIndex + position369, tokenIndex369 := position, tokenIndex { - position358 := position + position371 := position if !_rules[ruledigits]() { - goto l357 + goto l370 } - add(rulePegText, position358) - } - { - add(ruleAction50, position) - } - goto l356 - l357: - position, tokenIndex = position356, tokenIndex356 - { - position361 := position - if buffer[position] != rune('\'') { - goto l360 - } - position++ - if !_rules[rulesinglequotedstring]() { - goto l360 - } - if buffer[position] != rune('\'') { - goto l360 - } - position++ - add(rulePegText, position361) - } - { - add(ruleAction51, position) - } - goto l356 - l360: - position, tokenIndex = position356, tokenIndex356 - { - position363 := position - if buffer[position] != rune('"') { - goto l354 - } - position++ - if !_rules[ruledoublequotedstring]() { - goto l354 - } - if buffer[position] != rune('"') { - goto l354 - } - position++ - add(rulePegText, position363) + 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(ruleAction54, position) + } } - l356: - add(rulecol, position355) + l369: + add(rulecol, position368) } return true - l354: - position, tokenIndex = position354, tokenIndex354 + l367: + position, tokenIndex = position367, tokenIndex367 return false }, - /* 20 row <- <(( Action53) / (<('\'' singlequotedstring '\'')> Action54) / (<('"' doublequotedstring '"')> Action55))> */ + /* 20 row <- <(( Action55) / (<('\'' singlequotedstring '\'')> Action56) / (<('"' doublequotedstring '"')> Action57))> */ nil, /* 21 open <- <('(' sp)> */ func() bool { - position366, tokenIndex366 := position, tokenIndex + position379, tokenIndex379 := position, tokenIndex { - position367 := position + position380 := position if buffer[position] != rune('(') { - goto l366 + goto l379 } position++ if !_rules[rulesp]() { - goto l366 + goto l379 } - add(ruleopen, position367) + add(ruleopen, position380) } return true - l366: - position, tokenIndex = position366, tokenIndex366 + l379: + position, tokenIndex = position379, tokenIndex379 return false }, /* 22 close <- <(sp ')' sp)> */ func() bool { - position368, tokenIndex368 := position, tokenIndex + position381, tokenIndex381 := position, tokenIndex { - position369 := position + position382 := position if !_rules[rulesp]() { - goto l368 + goto l381 } if buffer[position] != rune(')') { - goto l368 + goto l381 } position++ if !_rules[rulesp]() { - goto l368 + goto l381 } - add(ruleclose, position369) + add(ruleclose, position382) } return true - l368: - position, tokenIndex = position368, tokenIndex368 + l381: + position, tokenIndex = position381, tokenIndex381 return false }, /* 23 sp <- <(' ' / '\t' / '\n')*> */ func() bool { { - position371 := position - l372: + position384 := position + l385: { - position373, tokenIndex373 := position, tokenIndex + position386, tokenIndex386 := position, tokenIndex { - position374, tokenIndex374 := position, tokenIndex + position387, tokenIndex387 := position, tokenIndex if buffer[position] != rune(' ') { - goto l375 + goto l388 } position++ - goto l374 - l375: - position, tokenIndex = position374, tokenIndex374 + goto l387 + l388: + position, tokenIndex = position387, tokenIndex387 if buffer[position] != rune('\t') { - goto l376 + goto l389 } position++ - goto l374 - l376: - position, tokenIndex = position374, tokenIndex374 + goto l387 + l389: + position, tokenIndex = position387, tokenIndex387 if buffer[position] != rune('\n') { - goto l373 + goto l386 } position++ } - l374: - goto l372 - l373: - position, tokenIndex = position373, tokenIndex373 + l387: + goto l385 + l386: + position, tokenIndex = position386, tokenIndex386 } - add(rulesp, position371) + add(rulesp, position384) } return true }, /* 24 eq <- <(sp '=' sp)> */ func() bool { - position377, tokenIndex377 := position, tokenIndex + position390, tokenIndex390 := position, tokenIndex { - position378 := position + position391 := position if !_rules[rulesp]() { - goto l377 + goto l390 } if buffer[position] != rune('=') { - goto l377 + goto l390 } position++ if !_rules[rulesp]() { - goto l377 + goto l390 } - add(ruleeq, position378) + add(ruleeq, position391) } return true - l377: - position, tokenIndex = position377, tokenIndex377 + l390: + position, tokenIndex = position390, tokenIndex390 return false }, /* 25 comma <- <(sp ',' sp)> */ func() bool { - position379, tokenIndex379 := position, tokenIndex + position392, tokenIndex392 := position, tokenIndex { - position380 := position + position393 := position if !_rules[rulesp]() { - goto l379 + goto l392 } if buffer[position] != rune(',') { - goto l379 + goto l392 } position++ if !_rules[rulesp]() { - goto l379 + goto l392 } - add(rulecomma, position380) + add(rulecomma, position393) } return true - l379: - position, tokenIndex = position379, tokenIndex379 + l392: + position, tokenIndex = position392, tokenIndex392 return false }, /* 26 lbrack <- <('[' sp)> */ @@ -3405,312 +3497,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 { - position383, tokenIndex383 := position, tokenIndex + position396, tokenIndex396 := position, tokenIndex { - position384 := position + position397 := position { - position385, tokenIndex385 := position, tokenIndex + position398, tokenIndex398 := position, tokenIndex if c := buffer[position]; c < rune('a') || c > rune('z') { - goto l386 + goto l399 } position++ - goto l385 - l386: - position, tokenIndex = position385, tokenIndex385 + goto l398 + l399: + position, tokenIndex = position398, tokenIndex398 if c := buffer[position]; c < rune('A') || c > rune('Z') { - goto l383 + goto l396 } position++ } - l385: - l387: + l398: + l400: { - position388, tokenIndex388 := position, tokenIndex + position401, tokenIndex401 := position, tokenIndex { - position389, tokenIndex389 := position, tokenIndex + position402, tokenIndex402 := position, tokenIndex if c := buffer[position]; c < rune('a') || c > rune('z') { - goto l390 + goto l403 } position++ - goto l389 - l390: - position, tokenIndex = position389, tokenIndex389 + goto l402 + l403: + position, tokenIndex = position402, tokenIndex402 if c := buffer[position]; c < rune('A') || c > rune('Z') { - goto l391 + goto l404 } position++ - goto l389 - l391: - position, tokenIndex = position389, tokenIndex389 + goto l402 + l404: + position, tokenIndex = position402, tokenIndex402 if c := buffer[position]; c < rune('0') || c > rune('9') { - goto l388 + goto l401 } position++ } - l389: - goto l387 - l388: - position, tokenIndex = position388, tokenIndex388 + l402: + goto l400 + l401: + position, tokenIndex = position401, tokenIndex401 } - add(ruleIDENT, position384) + add(ruleIDENT, position397) } return true - l383: - position, tokenIndex = position383, tokenIndex383 + l396: + position, tokenIndex = position396, tokenIndex396 return false }, /* 29 digits <- <[0-9]+> */ func() bool { - position392, tokenIndex392 := position, tokenIndex + position405, tokenIndex405 := position, tokenIndex { - position393 := position + position406 := position if c := buffer[position]; c < rune('0') || c > rune('9') { - goto l392 + goto l405 } position++ - l394: + l407: { - position395, tokenIndex395 := position, tokenIndex + position408, tokenIndex408 := position, tokenIndex if c := buffer[position]; c < rune('0') || c > rune('9') { - goto l395 + goto l408 } position++ - goto l394 - l395: - position, tokenIndex = position395, tokenIndex395 + goto l407 + l408: + position, tokenIndex = position408, tokenIndex408 } - add(ruledigits, position393) + add(ruledigits, position406) } return true - l392: - position, tokenIndex = position392, tokenIndex392 + l405: + position, tokenIndex = position405, tokenIndex405 return false }, /* 30 signedDigits <- <('-'? digits)> */ nil, /* 31 decimal <- <((signedDigits ('.' digits?)?) / ('-'? '.' digits))> */ - func() bool { - position397, tokenIndex397 := position, tokenIndex - { - position398 := position - { - position399, tokenIndex399 := position, tokenIndex - { - position401 := position - { - position402, tokenIndex402 := position, tokenIndex - if buffer[position] != rune('-') { - goto l402 - } - position++ - goto l403 - l402: - position, tokenIndex = position402, tokenIndex402 - } - l403: - if !_rules[ruledigits]() { - goto l400 - } - add(rulesignedDigits, position401) - } - { - position404, tokenIndex404 := position, tokenIndex - if buffer[position] != rune('.') { - goto l404 - } - position++ - { - position406, tokenIndex406 := position, tokenIndex - if !_rules[ruledigits]() { - goto l406 - } - goto l407 - l406: - position, tokenIndex = position406, tokenIndex406 - } - l407: - goto l405 - l404: - position, tokenIndex = position404, tokenIndex404 - } - l405: - goto l399 - l400: - position, tokenIndex = position399, tokenIndex399 - { - position408, tokenIndex408 := position, tokenIndex - if buffer[position] != rune('-') { - goto l408 - } - position++ - goto l409 - l408: - position, tokenIndex = position408, tokenIndex408 - } - l409: - if buffer[position] != rune('.') { - goto l397 - } - position++ - if !_rules[ruledigits]() { - goto l397 - } - } - l399: - add(ruledecimal, position398) - } - return true - l397: - position, tokenIndex = position397, tokenIndex397 - return false - }, - /* 32 timestampbasicfmt <- <([0-9] [0-9] [0-9] [0-9] '-' ('0' / '1') [0-9] '-' [0-3] [0-9] 'T' [0-9] [0-9] ':' [0-9] [0-9])> */ func() bool { position410, tokenIndex410 := position, tokenIndex { position411 := position - if c := buffer[position]; c < rune('0') || c > rune('9') { - goto l410 - } - position++ - if c := buffer[position]; c < rune('0') || c > rune('9') { - goto l410 - } - position++ - if c := buffer[position]; c < rune('0') || c > rune('9') { - goto l410 - } - position++ - if c := buffer[position]; c < rune('0') || c > rune('9') { - goto l410 - } - position++ - if buffer[position] != rune('-') { - goto l410 - } - position++ { position412, tokenIndex412 := position, tokenIndex - if buffer[position] != rune('0') { - goto l413 + { + position414 := position + { + position415, tokenIndex415 := position, tokenIndex + if buffer[position] != rune('-') { + goto l415 + } + position++ + goto l416 + l415: + position, tokenIndex = position415, tokenIndex415 + } + l416: + if !_rules[ruledigits]() { + goto l413 + } + add(rulesignedDigits, position414) } - position++ + { + position417, tokenIndex417 := position, tokenIndex + if buffer[position] != rune('.') { + goto l417 + } + position++ + { + position419, tokenIndex419 := position, tokenIndex + if !_rules[ruledigits]() { + goto l419 + } + goto l420 + l419: + position, tokenIndex = position419, tokenIndex419 + } + l420: + goto l418 + l417: + position, tokenIndex = position417, tokenIndex417 + } + l418: goto l412 l413: position, tokenIndex = position412, tokenIndex412 - if buffer[position] != rune('1') { + { + position421, tokenIndex421 := position, tokenIndex + if buffer[position] != rune('-') { + goto l421 + } + position++ + goto l422 + l421: + position, tokenIndex = position421, tokenIndex421 + } + l422: + if buffer[position] != rune('.') { goto l410 } position++ + if !_rules[ruledigits]() { + goto l410 + } } l412: - if c := buffer[position]; c < rune('0') || c > rune('9') { - goto l410 - } - position++ - if buffer[position] != rune('-') { - goto l410 - } - position++ - if c := buffer[position]; c < rune('0') || c > rune('3') { - goto l410 - } - position++ - if c := buffer[position]; c < rune('0') || c > rune('9') { - goto l410 - } - position++ - if buffer[position] != rune('T') { - goto l410 - } - position++ - if c := buffer[position]; c < rune('0') || c > rune('9') { - goto l410 - } - position++ - if c := buffer[position]; c < rune('0') || c > rune('9') { - goto l410 - } - position++ - if buffer[position] != rune(':') { - goto l410 - } - position++ - if c := buffer[position]; c < rune('0') || c > rune('9') { - goto l410 - } - position++ - if c := buffer[position]; c < rune('0') || c > rune('9') { - goto l410 - } - position++ - add(ruletimestampbasicfmt, position411) + add(ruledecimal, position411) } return true l410: position, tokenIndex = position410, tokenIndex410 return false }, - /* 33 timestampfmt <- <(('"' '"') / ('\'' '\'') / )> */ + /* 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 { - position414, tokenIndex414 := position, tokenIndex + position423, tokenIndex423 := position, tokenIndex { - position415 := position - { - position416, tokenIndex416 := position, tokenIndex - if buffer[position] != rune('"') { - goto l417 - } - position++ - { - position418 := position - if !_rules[ruletimestampbasicfmt]() { - goto l417 - } - add(rulePegText, position418) - } - if buffer[position] != rune('"') { - goto l417 - } - position++ - goto l416 - l417: - position, tokenIndex = position416, tokenIndex416 - if buffer[position] != rune('\'') { - goto l419 - } - position++ - { - position420 := position - if !_rules[ruletimestampbasicfmt]() { - goto l419 - } - add(rulePegText, position420) - } - if buffer[position] != rune('\'') { - goto l419 - } - position++ - goto l416 - l419: - position, tokenIndex = position416, tokenIndex416 - { - position421 := position - if !_rules[ruletimestampbasicfmt]() { - goto l414 - } - add(rulePegText, position421) - } + position424 := position + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l423 } - l416: - add(ruletimestampfmt, position415) + position++ + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l423 + } + position++ + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l423 + } + position++ + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l423 + } + position++ + if buffer[position] != rune('-') { + goto l423 + } + position++ + { + position425, tokenIndex425 := position, tokenIndex + if buffer[position] != rune('0') { + goto l426 + } + position++ + goto l425 + l426: + position, tokenIndex = position425, tokenIndex425 + if buffer[position] != rune('1') { + goto l423 + } + position++ + } + l425: + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l423 + } + position++ + if buffer[position] != rune('-') { + goto l423 + } + position++ + if c := buffer[position]; c < rune('0') || c > rune('3') { + goto l423 + } + position++ + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l423 + } + position++ + if buffer[position] != rune('T') { + goto l423 + } + position++ + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l423 + } + position++ + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l423 + } + position++ + if buffer[position] != rune(':') { + goto l423 + } + position++ + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l423 + } + position++ + if c := buffer[position]; c < rune('0') || c > rune('9') { + goto l423 + } + position++ + add(ruletimestampbasicfmt, position424) } return true - l414: - position, tokenIndex = position414, tokenIndex414 + l423: + position, tokenIndex = position423, tokenIndex423 return false }, - /* 34 timestamp <- <( Action56)> */ + /* 33 timestampfmt <- <(('"' '"') / ('\'' '\'') / )> */ + func() bool { + position427, tokenIndex427 := position, tokenIndex + { + position428 := position + { + position429, tokenIndex429 := position, tokenIndex + if buffer[position] != rune('"') { + goto l430 + } + position++ + { + position431 := position + if !_rules[ruletimestampbasicfmt]() { + goto l430 + } + add(rulePegText, position431) + } + if buffer[position] != rune('"') { + goto l430 + } + position++ + goto l429 + l430: + position, tokenIndex = position429, tokenIndex429 + if buffer[position] != rune('\'') { + goto l432 + } + position++ + { + position433 := position + if !_rules[ruletimestampbasicfmt]() { + goto l432 + } + add(rulePegText, position433) + } + if buffer[position] != rune('\'') { + goto l432 + } + position++ + goto l429 + l432: + position, tokenIndex = position429, tokenIndex429 + { + position434 := position + if !_rules[ruletimestampbasicfmt]() { + goto l427 + } + add(rulePegText, position434) + } + } + l429: + add(ruletimestampfmt, position428) + } + return true + l427: + position, tokenIndex = position427, tokenIndex427 + return false + }, + /* 34 timestamp <- <( Action58)> */ nil, /* 36 Action0 <- <{p.startCall("Set")}> */ nil, @@ -3740,92 +3832,96 @@ func (p *PQL) Init(options ...func(*PQL) error) error { nil, /* 49 Action13 <- <{p.endCall()}> */ nil, - /* 50 Action14 <- <{p.startCall("Rows")}> */ + /* 50 Action14 <- <{p.startCall("TopK")}> */ nil, /* 51 Action15 <- <{p.endCall()}> */ nil, - /* 52 Action16 <- <{p.startCall("Range")}> */ + /* 52 Action16 <- <{p.startCall("Rows")}> */ nil, - /* 53 Action17 <- <{p.addField("from")}> */ + /* 53 Action17 <- <{p.endCall()}> */ nil, - /* 54 Action18 <- <{p.addVal(text)}> */ + /* 54 Action18 <- <{p.startCall("Range")}> */ nil, - /* 55 Action19 <- <{p.addField("to")}> */ + /* 55 Action19 <- <{p.addField("from")}> */ nil, /* 56 Action20 <- <{p.addVal(text)}> */ nil, - /* 57 Action21 <- <{p.endCall()}> */ + /* 57 Action21 <- <{p.addField("to")}> */ + nil, + /* 58 Action22 <- <{p.addVal(text)}> */ + nil, + /* 59 Action23 <- <{p.endCall()}> */ nil, nil, - /* 59 Action22 <- <{ p.startCall(text) }> */ + /* 61 Action24 <- <{ p.startCall(text) }> */ nil, - /* 60 Action23 <- <{ p.endCall() }> */ + /* 62 Action25 <- <{ p.endCall() }> */ nil, - /* 61 Action24 <- <{ p.addBTWN() }> */ + /* 63 Action26 <- <{ p.addBTWN() }> */ nil, - /* 62 Action25 <- <{ p.addLTE() }> */ + /* 64 Action27 <- <{ p.addLTE() }> */ nil, - /* 63 Action26 <- <{ p.addGTE() }> */ + /* 65 Action28 <- <{ p.addGTE() }> */ nil, - /* 64 Action27 <- <{ p.addEQ() }> */ + /* 66 Action29 <- <{ p.addEQ() }> */ nil, - /* 65 Action28 <- <{ p.addNEQ() }> */ + /* 67 Action30 <- <{ p.addNEQ() }> */ nil, - /* 66 Action29 <- <{ p.addLT() }> */ + /* 68 Action31 <- <{ p.addLT() }> */ nil, - /* 67 Action30 <- <{ p.addGT() }> */ + /* 69 Action32 <- <{ p.addGT() }> */ nil, - /* 68 Action31 <- <{p.startConditional()}> */ + /* 70 Action33 <- <{p.startConditional()}> */ nil, - /* 69 Action32 <- <{p.endConditional()}> */ - nil, - /* 70 Action33 <- <{p.condAdd(text)}> */ - nil, - /* 71 Action34 <- <{p.condAdd(text)}> */ + /* 71 Action34 <- <{p.endConditional()}> */ nil, /* 72 Action35 <- <{p.condAdd(text)}> */ nil, - /* 73 Action36 <- <{ p.startList() }> */ + /* 73 Action36 <- <{p.condAdd(text)}> */ nil, - /* 74 Action37 <- <{ p.endList() }> */ + /* 74 Action37 <- <{p.condAdd(text)}> */ nil, - /* 75 Action38 <- <{ p.addVal(nil) }> */ + /* 75 Action38 <- <{ p.startList() }> */ nil, - /* 76 Action39 <- <{ p.addVal(true) }> */ + /* 76 Action39 <- <{ p.endList() }> */ nil, - /* 77 Action40 <- <{ p.addVal(false) }> */ + /* 77 Action40 <- <{ p.addVal(nil) }> */ nil, - /* 78 Action41 <- <{ p.addVal(text) }> */ + /* 78 Action41 <- <{ p.addVal(true) }> */ nil, - /* 79 Action42 <- <{ p.addNumVal(text) }> */ + /* 79 Action42 <- <{ p.addVal(false) }> */ nil, - /* 80 Action43 <- <{ p.startCall(text) }> */ + /* 80 Action43 <- <{ p.addVal(text) }> */ nil, - /* 81 Action44 <- <{ p.addVal(p.endCall()) }> */ + /* 81 Action44 <- <{ p.addNumVal(text) }> */ nil, - /* 82 Action45 <- <{ p.addVal(text) }> */ + /* 82 Action45 <- <{ p.startCall(text) }> */ nil, - /* 83 Action46 <- <{ p.addVal(text) }> */ + /* 83 Action46 <- <{ p.addVal(p.endCall()) }> */ nil, /* 84 Action47 <- <{ p.addVal(text) }> */ nil, - /* 85 Action48 <- <{ p.addField(text) }> */ + /* 85 Action48 <- <{ p.addVal(text) }> */ nil, - /* 86 Action49 <- <{ p.addPosStr("_field", text) }> */ + /* 86 Action49 <- <{ p.addVal(text) }> */ nil, - /* 87 Action50 <- <{p.addPosNum("_col", text)}> */ + /* 87 Action50 <- <{ p.addField(text) }> */ nil, - /* 88 Action51 <- <{p.addPosStr("_col", text)}> */ + /* 88 Action51 <- <{ p.addPosStr("_field", text) }> */ nil, - /* 89 Action52 <- <{p.addPosStr("_col", text)}> */ + /* 89 Action52 <- <{p.addPosNum("_col", text)}> */ nil, - /* 90 Action53 <- <{p.addPosNum("_row", text)}> */ + /* 90 Action53 <- <{p.addPosStr("_col", text)}> */ nil, - /* 91 Action54 <- <{p.addPosStr("_row", text)}> */ + /* 91 Action54 <- <{p.addPosStr("_col", text)}> */ nil, - /* 92 Action55 <- <{p.addPosStr("_row", text)}> */ + /* 92 Action55 <- <{p.addPosNum("_row", text)}> */ nil, - /* 93 Action56 <- <{p.addPosStr("_timestamp", text)}> */ + /* 93 Action56 <- <{p.addPosStr("_row", text)}> */ + nil, + /* 94 Action57 <- <{p.addPosStr("_row", text)}> */ + nil, + /* 95 Action58 <- <{p.addPosStr("_timestamp", text)}> */ nil, } p.rules = _rules