From ca047193ee2d650158b7ed1c4efadee7220f2ed5 Mon Sep 17 00:00:00 2001 From: Vladimir Hodakov Date: Sat, 19 Oct 2019 01:17:00 +0400 Subject: [PATCH] Fix golint errors and export all returnable types --- constants.go | 8 +++---- eval.go | 31 ++++++++++++++++++--------- eval_states.go | 24 +++++++++++++++------ expression.go | 53 ++++++++++++++++++++++++---------------------- expression_test.go | 18 ++++++++-------- json_states.go | 14 ++++++------ lexer_reader.go | 30 +++++++++++++------------- lexer_slice.go | 26 +++++++++++------------ path.go | 27 +++++++++++++++++------ queue.go | 2 +- 10 files changed, 135 insertions(+), 98 deletions(-) diff --git a/constants.go b/constants.go index 4bd54b4..b3bdb79 100644 --- a/constants.go +++ b/constants.go @@ -1,10 +1,10 @@ package jsonpath const ( - BadStructure = "Bad Structure" - NoMoreResults = "No more results" - UnexpectedToken = "Unexpected token in evaluation" - AbruptTokenStreamEnd = "Token reader is not sending anymore tokens" + BadStructure = "bad structure" + NoMoreResults = "no more results" + UnexpectedToken = "unexpected token in evaluation" + AbruptTokenStreamEnd = "token reader is not sending anymore tokens" ) var ( diff --git a/eval.go b/eval.go index 56203da..63d8592 100644 --- a/eval.go +++ b/eval.go @@ -49,7 +49,7 @@ func newEvaluation(tr tokenReader, paths ...*Path) *Eval { location: *newStack(), levelStack: *newIntStack(), state: evalRoot, - queries: make(map[string]*query, 0), + queries: make(map[string]*query), prevIndex: -1, nextKey: nil, copyValues: true, // depends on which lexer is used @@ -61,7 +61,7 @@ func newEvaluation(tr tokenReader, paths ...*Path) *Eval { } // Determine whether to copy emitted item values ([]byte) from lexer switch tr.(type) { - case *readerLexer: + case *ReaderLexer: e.copyValues = true default: e.copyValues = false @@ -100,6 +100,7 @@ func (e *Eval) Iterate() (*Results, bool) { for str, query := range e.queries { anyRunning = true query.state = query.state(query, e, t) + if query.state == nil { delete(e.queries, str) } @@ -144,8 +145,8 @@ func (e *Eval) Next() (*Result, bool) { } else { break } - } + return nil, false } @@ -163,9 +164,12 @@ func (q *query) trySpillOver() { if err != nil { q.errors = append(q.errors, err) } + if exprRes { next, ok := q.buckets.peek() + var spillover *Results + if !ok { // fmt.Println("Spilling over into end queue") spillover = q.resultQueue @@ -174,6 +178,7 @@ func (q *query) trySpillOver() { nextBucket := next.(exprBucket) spillover = nextBucket.results } + for { v := bucket.results.Pop() if v != nil { @@ -191,7 +196,7 @@ func pathMatchOp(q *query, e *Eval, i *Item) queryStateFn { curLocation := e.location.len() - 1 if q.loc() > curLocation { - q.pos -= 1 + q.pos-- q.trySpillOver() } else if q.loc() <= curLocation { if q.loc() == curLocation-1 { @@ -218,7 +223,6 @@ func pathMatchOp(q *query, e *Eval, i *Item) queryStateFn { q.buckets.push(bucket) } } - } } } @@ -228,15 +232,17 @@ func pathMatchOp(q *query, e *Eval, i *Item) queryStateFn { q.firstType = i.typ q.buffer.Write(i.val) } + q.valLoc = *e.location.clone() + return pathEndValue } if q.loc() < -1 { return nil - } else { - return pathMatchOp } + + return pathMatchOp } func pathEndValue(q *query, e *Eval, i *Item) queryStateFn { @@ -278,14 +284,16 @@ func pathEndValue(q *query, e *Eval, i *Item) queryStateFn { q.valLoc = *newStack() q.buffer.Truncate(0) - q.pos -= 1 + q.pos-- return pathMatchOp } + return pathEndValue } func (b *exprBucket) evaluate() (bool, error) { values := make(map[string]Item) + for _, q := range b.queries { result := q.resultQueue.Pop() if result != nil { @@ -293,6 +301,7 @@ func (b *exprBucket) evaluate() (bool, error) { if err != nil { return false, err } + i := Item{ typ: t, val: result.Value, @@ -305,11 +314,13 @@ func (b *exprBucket) evaluate() (bool, error) { if err != nil { return false, err } - res_bool, ok := res.(bool) + + resBool, ok := res.(bool) if !ok { return false, fmt.Errorf(exprErrorFinalValueNotBool, res) } - return res_bool, nil + + return resBool, nil } func itemMatchOperator(loc interface{}, op *operator) bool { diff --git a/eval_states.go b/eval_states.go index 16db87e..6e93ed4 100644 --- a/eval_states.go +++ b/eval_states.go @@ -18,6 +18,7 @@ func evalRoot(e *Eval, i *Item) evalStateFn { default: e.Error = errors.New(UnexpectedToken) } + return nil } @@ -25,12 +26,16 @@ func evalObjectAfterOpen(e *Eval, i *Item) evalStateFn { switch i.typ { case jsonKey: c := i.val[1 : len(i.val)-1] + if e.copyValues { d := make([]byte, len(c)) copy(d, c) + c = d } + e.nextKey = c + return evalObjectColon case jsonBraceRight: return rightBraceOrBracket(e) @@ -39,6 +44,7 @@ func evalObjectAfterOpen(e *Eval, i *Item) evalStateFn { default: e.Error = errors.New(UnexpectedToken) } + return nil } @@ -72,11 +78,13 @@ func evalObjectValue(e *Eval, i *Item) evalStateFn { default: e.Error = errors.New(UnexpectedToken) } + return nil } func evalObjectAfterValue(e *Eval, i *Item) evalStateFn { e.location.pop() + switch i.typ { case jsonComma: return evalObjectAfterOpen @@ -87,6 +95,7 @@ func evalObjectAfterValue(e *Eval, i *Item) evalStateFn { default: e.Error = errors.New(UnexpectedToken) } + return nil } @@ -96,14 +105,15 @@ func rightBraceOrBracket(e *Eval) evalStateFn { lowerTyp, ok := e.levelStack.peek() if !ok { return evalRootEnd - } else { - switch lowerTyp { - case jsonBraceLeft: - return evalObjectAfterValue - case jsonBracketLeft: - return evalArrayAfterValue - } } + + switch lowerTyp { + case jsonBraceLeft: + return evalObjectAfterValue + case jsonBracketLeft: + return evalArrayAfterValue + } + return nil } diff --git a/expression.go b/expression.go index 621ba13..3c15077 100644 --- a/expression.go +++ b/expression.go @@ -9,13 +9,13 @@ import ( ) const ( - exprErrorMismatchedParens = "Mismatched parentheses" - exprErrorBadExpression = "Bad Expression" - exprErrorFinalValueNotBool = "Expression evaluated to a non-bool: %v" - exprErrorNotEnoughOperands = "Not enough operands for operation %q" - exprErrorValueNotFound = "Value for %q not found" - exprErrorBadValue = "Bad value %q for type %q" - exprErrorPathValueNotScalar = "Path value must be scalar value" + exprErrorMismatchedParens = "mismatched parentheses" + exprErrorBadExpression = "bad expression" + exprErrorFinalValueNotBool = "expression evaluated to a non-bool: %v" + exprErrorNotEnoughOperands = "not enough operands for operation %q" + exprErrorValueNotFound = "value for %q not found" + exprErrorBadValue = "bad value %q for type %q" + exprErrorPathValueNotScalar = "path value must be scalar value" ) type exprErrorBadTypeComparison struct { @@ -141,15 +141,16 @@ func evaluatePostFix(postFixItems []Item, pathValues map[string]Item) (interface if !ok { return false, fmt.Errorf(exprErrorValueNotFound, string(item.val)) } + switch i.typ { case jsonNull: s.push(nil) case jsonNumber: - val_float, err := strconv.ParseFloat(string(i.val), 64) + valFloat, err := strconv.ParseFloat(string(i.val), 64) if err != nil { return false, fmt.Errorf(exprErrorBadValue, string(item.val), jsonTokenNames[jsonNumber]) } - s.push(val_float) + s.push(valFloat) case jsonKey, jsonString: s.push(i.val) default: @@ -173,14 +174,15 @@ func evaluatePostFix(postFixItems []Item, pathValues map[string]Item) (interface if !ok { return false, fmt.Errorf(exprErrorNotEnoughOperands, exprTokenNames[item.typ]) } + switch p.(type) { case nil: err := take2Null(s, item.typ) if err != nil { return false, err - } else { - s.push(true) } + + s.push(true) case bool: a, b, err := take2Bool(s, item.typ) if err != nil { @@ -205,14 +207,15 @@ func evaluatePostFix(postFixItems []Item, pathValues map[string]Item) (interface if !ok { return false, fmt.Errorf(exprErrorNotEnoughOperands, exprTokenNames[item.typ]) } + switch p.(type) { case nil: err := take2Null(s, item.typ) if err != nil { return true, err - } else { - s.push(false) } + + s.push(false) case bool: a, b, err := take2Bool(s, item.typ) if err != nil { @@ -363,9 +366,9 @@ func take1Bool(s *stack, op int) (bool, error) { } func take2Bool(s *stack, op int) (bool, bool, error) { - a, a_err := take1Bool(s, op) - b, b_err := take1Bool(s, op) - return a, b, firstError(a_err, b_err) + a, aErr := take1Bool(s, op) + b, bErr := take1Bool(s, op) + return a, b, firstError(aErr, bErr) } func take1Float(s *stack, op int) (float64, error) { @@ -383,9 +386,9 @@ func take1Float(s *stack, op int) (float64, error) { } func take2Float(s *stack, op int) (float64, float64, error) { - a, a_err := take1Float(s, op) - b, b_err := take1Float(s, op) - return a, b, firstError(a_err, b_err) + a, aErr := take1Float(s, op) + b, bErr := take1Float(s, op) + return a, b, firstError(aErr, bErr) } func take1ByteSlice(s *stack, op int) ([]byte, error) { @@ -403,9 +406,9 @@ func take1ByteSlice(s *stack, op int) ([]byte, error) { } func take2ByteSlice(s *stack, op int) ([]byte, []byte, error) { - a, a_err := take1ByteSlice(s, op) - b, b_err := take1ByteSlice(s, op) - return a, b, firstError(a_err, b_err) + a, aErr := take1ByteSlice(s, op) + b, bErr := take1ByteSlice(s, op) + return a, b, firstError(aErr, bErr) } func take1Null(s *stack, op int) error { @@ -422,7 +425,7 @@ func take1Null(s *stack, op int) error { } func take2Null(s *stack, op int) error { - a_err := take1Null(s, op) - b_err := take1Null(s, op) - return firstError(a_err, b_err) + aErr := take1Null(s, op) + bErr := take1Null(s, op) + return firstError(aErr, bErr) } diff --git a/expression_test.go b/expression_test.go index fca4903..38e95e0 100644 --- a/expression_test.go +++ b/expression_test.go @@ -149,9 +149,9 @@ func TestExpressions(t *testing.T) { items := readerToArray(lexer) // trim EOF items = items[0 : len(items)-1] - items_post, err := infixToPostFix(items) + itemsPost, err := infixToPostFix(items) if as.NoError(err, "Could not transform to postfix\nTest: %q", test.input) { - val, err := evaluatePostFix(items_post, test.fields) + val, err := evaluatePostFix(itemsPost, test.fields) if as.NoError(err, "Could not evaluate postfix\nTest Input: %q\nTest Values:%q\nError:%q", test.input, test.fields, err) { as.EqualValues(test.expectedValue, val, "\nTest: %q\nActual: %v \nExpected %v\n", test.input, val, test.expectedValue) } @@ -165,8 +165,8 @@ var exprErrorTests = []struct { expectedErrorSubstring string }{ {"@a == @b", map[string]Item{"@a": genValue(`"one"`, jsonString), "@b": genValue("3.4", jsonNumber)}, "cannot be compared"}, - {")(", nil, "Mismatched parentheses"}, - {")123", nil, "Mismatched parentheses"}, + {")(", nil, "mismatched parentheses"}, + {")123", nil, "mismatched parentheses"}, {"20 == null", nil, "cannot be compared"}, {`"toronto" == null`, nil, "cannot be compared"}, {`false == 20`, nil, "cannot be compared"}, @@ -175,9 +175,9 @@ var exprErrorTests = []struct { {`"toronto" != null`, nil, "cannot be compared"}, {`false != 20`, nil, "cannot be compared"}, {`"nick" != 20`, nil, "cannot be compared"}, - {``, nil, "Bad Expression"}, - {`==`, nil, "Bad Expression"}, - {`!=`, nil, "Not enough operands"}, + {``, nil, "bad expression"}, + {`==`, nil, "bad expression"}, + {`!=`, nil, "not enough operands"}, {`!23`, nil, "cannot be compared"}, {`"nick" || true`, nil, "cannot be compared"}, @@ -210,13 +210,13 @@ func TestBadExpressions(t *testing.T) { items := readerToArray(lexer) // trim EOF items = items[0 : len(items)-1] - items_post, err := infixToPostFix(items) + itemsPost, err := infixToPostFix(items) if err != nil { as.True(strings.Contains(err.Error(), test.expectedErrorSubstring), "Test Input: %q\nError %q does not contain %q", test.input, err.Error(), test.expectedErrorSubstring) continue } if as.NoError(err, "Could not transform to postfix\nTest: %q", test.input) { - _, err := evaluatePostFix(items_post, test.fields) + _, err := evaluatePostFix(itemsPost, test.fields) if as.Error(err, "Could not evaluate postfix\nTest Input: %q\nTest Values:%q\nError:%s", test.input, test.fields, err) { as.True(strings.Contains(err.Error(), test.expectedErrorSubstring), "Test Input: %q\nError %s does not contain %q", test.input, err.Error(), test.expectedErrorSubstring) } diff --git a/json_states.go b/json_states.go index 9e33c56..960a2db 100644 --- a/json_states.go +++ b/json_states.go @@ -134,9 +134,9 @@ func stateJSONAfterValue(l lexer, state *intStack) stateFn { case jsonBracketLeft: return stateJSONValue case noValue: - return l.errorf("Found %#U outside of array or object", cur) + return l.errorf("found %#U outside of array or object", cur) default: - return l.errorf("Unexpected character in lexer stack: %#U", cur) + return l.errorf("unexpected character in lexer stack: %#U", cur) } case '}': l.emit(jsonBraceRight) @@ -145,7 +145,7 @@ func stateJSONAfterValue(l lexer, state *intStack) stateFn { case jsonBraceLeft: return stateJSONAfterValue case jsonBracketLeft: - return l.errorf("Unexpected %#U in array", cur) + return l.errorf("unexpected %#U in array", cur) case noValue: return stateJSONAfterRoot } @@ -154,7 +154,7 @@ func stateJSONAfterValue(l lexer, state *intStack) stateFn { state.pop() switch topVal { case jsonBraceLeft: - return l.errorf("Unexpected %#U in object", cur) + return l.errorf("unexpected %#U in object", cur) case jsonBracketLeft: return stateJSONAfterValue case noValue: @@ -164,11 +164,11 @@ func stateJSONAfterValue(l lexer, state *intStack) stateFn { if state.len() == 0 { l.emit(jsonEOF) return nil - } else { - return l.errorf("Unexpected EOF instead of value") } + + return l.errorf("unexpected EOF instead of value") default: - return l.errorf("Unexpected character after json value token: %#U", cur) + return l.errorf("unexpected character after json value token: %#U", cur) } return nil } diff --git a/lexer_reader.go b/lexer_reader.go index 066d8dc..d98e331 100644 --- a/lexer_reader.go +++ b/lexer_reader.go @@ -8,7 +8,7 @@ import ( "io" ) -type readerLexer struct { +type ReaderLexer struct { lex bufInput *bufio.Reader input io.Reader @@ -17,8 +17,8 @@ type readerLexer struct { lexeme *bytes.Buffer } -func NewReaderLexer(rr io.Reader, initial stateFn) *readerLexer { - l := readerLexer{ +func NewReaderLexer(rr io.Reader, initial stateFn) *ReaderLexer { + l := ReaderLexer{ input: rr, bufInput: bufio.NewReader(rr), nextByte: noValue, @@ -28,7 +28,7 @@ func NewReaderLexer(rr io.Reader, initial stateFn) *readerLexer { return &l } -func (l *readerLexer) take() int { +func (l *ReaderLexer) take() int { if l.nextByte == noValue { l.peek() } @@ -39,10 +39,10 @@ func (l *readerLexer) take() int { return nr } -func (l *readerLexer) takeString() error { +func (l *ReaderLexer) takeString() error { cur := l.take() if cur != '"' { - return fmt.Errorf("Expected \" as start of string instead of %#U", cur) + return fmt.Errorf("expected \" as start of string instead of %#U", cur) } var previous byte @@ -50,7 +50,7 @@ looper: for { curByte, err := l.bufInput.ReadByte() if err == io.EOF { - return errors.New("Unexpected EOF in string") + return errors.New("unexpected EOF in string") } l.lexeme.WriteByte(curByte) @@ -60,7 +60,7 @@ looper: } else { curByte, err = l.bufInput.ReadByte() if err == io.EOF { - return errors.New("Unexpected EOF in string") + return errors.New("unexpected EOF in string") } l.lexeme.WriteByte(curByte) } @@ -71,7 +71,7 @@ looper: return nil } -func (l *readerLexer) peek() int { +func (l *ReaderLexer) peek() int { if l.nextByte != noValue { return l.nextByte } @@ -86,7 +86,7 @@ func (l *readerLexer) peek() int { return l.nextByte } -func (l *readerLexer) emit(t int) { +func (l *ReaderLexer) emit(t int) { l.setItem(t, l.pos, l.lexeme.Bytes()) l.pos += Pos(l.lexeme.Len()) l.hasItem = true @@ -117,18 +117,18 @@ func (l *readerLexer) emit(t int) { } } -func (l *readerLexer) setItem(typ int, pos Pos, val []byte) { +func (l *ReaderLexer) setItem(typ int, pos Pos, val []byte) { l.item.typ = typ l.item.pos = pos l.item.val = val } -func (l *readerLexer) ignore() { +func (l *ReaderLexer) ignore() { l.pos += Pos(l.lexeme.Len()) l.lexeme.Reset() } -func (l *readerLexer) next() (*Item, bool) { +func (l *ReaderLexer) next() (*Item, bool) { l.lexeme.Reset() for { if l.currentStateFn == nil { @@ -145,14 +145,14 @@ func (l *readerLexer) next() (*Item, bool) { return &l.item, false } -func (l *readerLexer) errorf(format string, args ...interface{}) stateFn { +func (l *ReaderLexer) errorf(format string, args ...interface{}) stateFn { l.setItem(lexError, l.pos, []byte(fmt.Sprintf(format, args...))) l.lexeme.Truncate(0) l.hasItem = true return nil } -func (l *readerLexer) reset() { +func (l *ReaderLexer) reset() { l.bufInput.Reset(l.input) l.lexeme.Reset() l.nextByte = noValue diff --git a/lexer_slice.go b/lexer_slice.go index 0d5aa66..ec62cc0 100644 --- a/lexer_slice.go +++ b/lexer_slice.go @@ -5,31 +5,31 @@ import ( "fmt" ) -type sliceLexer struct { +type SliceLexer struct { lex input []byte // the []byte being scanned. start Pos // start position of this Item. pos Pos // current position in the input } -func NewSliceLexer(input []byte, initial stateFn) *sliceLexer { - l := &sliceLexer{ +func NewSliceLexer(input []byte, initial stateFn) *SliceLexer { + l := &SliceLexer{ lex: newLex(initial), input: input, } return l } -func (l *sliceLexer) take() int { +func (l *SliceLexer) take() int { if int(l.pos) >= len(l.input) { return eof } r := int(l.input[l.pos]) - l.pos += 1 + l.pos++ return r } -func (l *sliceLexer) takeString() error { +func (l *SliceLexer) takeString() error { curPos := l.pos inputLen := len(l.input) @@ -67,14 +67,14 @@ looper: return nil } -func (l *sliceLexer) peek() int { +func (l *SliceLexer) peek() int { if int(l.pos) >= len(l.input) { return eof } return int(l.input[l.pos]) } -func (l *sliceLexer) emit(t int) { +func (l *SliceLexer) emit(t int) { l.setItem(t, l.start, l.input[l.start:l.pos]) l.hasItem = true @@ -91,17 +91,17 @@ func (l *sliceLexer) emit(t int) { l.start = l.pos } -func (l *sliceLexer) setItem(typ int, pos Pos, val []byte) { +func (l *SliceLexer) setItem(typ int, pos Pos, val []byte) { l.item.typ = typ l.item.pos = pos l.item.val = val } -func (l *sliceLexer) ignore() { +func (l *SliceLexer) ignore() { l.start = l.pos } -func (l *sliceLexer) next() (*Item, bool) { +func (l *SliceLexer) next() (*Item, bool) { for { if l.currentStateFn == nil { break @@ -117,14 +117,14 @@ func (l *sliceLexer) next() (*Item, bool) { return &l.item, false } -func (l *sliceLexer) errorf(format string, args ...interface{}) stateFn { +func (l *SliceLexer) errorf(format string, args ...interface{}) stateFn { l.setItem(lexError, l.start, []byte(fmt.Sprintf(format, args...))) l.start = l.pos l.hasItem = true return nil } -func (l *sliceLexer) reset() { +func (l *SliceLexer) reset() { l.start = 0 l.pos = 0 l.lex = newLex(l.initialState) diff --git a/path.go b/path.go index 081b341..dcfdb94 100644 --- a/path.go +++ b/path.go @@ -33,6 +33,7 @@ type operator struct { whereClause []Item } +// nolint:gocognit func genIndexKey(tr tokenReader) (*operator, error) { k := &operator{} var t *Item @@ -63,34 +64,36 @@ func genIndexKey(tr tokenReader) (*operator, error) { if t, ok = tr.next(); !ok { return nil, errors.New("Expected number or *, but got none") } + switch t.typ { case pathIndexRange: if t, ok = tr.next(); !ok { - return nil, errors.New("Expected number or *, but got none") + return nil, errors.New("expected number or *, but got none") } + switch t.typ { case pathIndex: v, err := strconv.Atoi(string(t.val)) if err != nil { - return nil, fmt.Errorf("Could not parse %q into int64", t.val) + return nil, fmt.Errorf("could not parse %q into int64", t.val) } k.indexEnd = v - 1 k.hasIndexEnd = true if t, ok = tr.next(); !ok || t.typ != pathBracketRight { - return nil, errors.New("Expected ], but got none") + return nil, errors.New("expected ], but got none") } case pathBracketRight: k.hasIndexEnd = false default: - return nil, fmt.Errorf("Unexpected value within brackets after index: %q", t.val) + return nil, fmt.Errorf("unexpected value within brackets after index: %q", t.val) } k.typ = opTypeIndexRange case pathBracketRight: k.typ = opTypeIndex default: - return nil, fmt.Errorf("Unexpected value within brackets after index: %q", t.val) + return nil, fmt.Errorf("unexpected value within brackets after index: %q", t.val) } case pathKey: k.keyStrings = map[string]struct{}{ @@ -99,10 +102,10 @@ func genIndexKey(tr tokenReader) (*operator, error) { k.typ = opTypeName if t, ok = tr.next(); !ok || t.typ != pathBracketRight { - return nil, errors.New("Expected ], but got none") + return nil, errors.New("expected ], but got none") } default: - return nil, fmt.Errorf("Unexpected value within brackets: %q", t.val) + return nil, fmt.Errorf("unexpected value within brackets: %q", t.val) } return k, nil @@ -166,21 +169,26 @@ func tokensToOperators(tr tokenReader) (*Path, error) { return nil, errors.New("Unexpected root node after start") } continue + case pathCurrent: if len(q.operators) != 0 { return nil, errors.New("Unexpected current node after start") } continue + case pathPeriod: continue + case pathBracketLeft: k, err := genIndexKey(tr) if err != nil { return nil, err } q.operators = append(q.operators, k) + case pathKey: keyName := p.val + if len(p.val) == 0 { return nil, fmt.Errorf("Key length is zero at %d", p.pos) } @@ -196,11 +204,15 @@ func tokensToOperators(tr tokenReader) (*Path, error) { }, }, ) + case pathWildcard: q.operators = append(q.operators, &operator{typ: opTypeNameWild}) + case pathValue: q.captureEndValue = true + case pathWhere: + case pathExpression: if len(q.operators) == 0 { return nil, errors.New("Cannot add where clause on last key") @@ -210,6 +222,7 @@ func tokensToOperators(tr tokenReader) (*Path, error) { return nil, errors.New("Expression on last key already set") } last.whereClauseBytes = p.val + case pathError: return q, errors.New(string(p.val)) } diff --git a/queue.go b/queue.go index d7cdf49..0e8a643 100644 --- a/queue.go +++ b/queue.go @@ -9,7 +9,7 @@ type Results struct { func newResults() *Results { return &Results{ - nodes: make([]*Result, 3, 3), + nodes: make([]*Result, 3), } }