Upgrade server dependencies, manage them with govendor

vendor/github.com/blevesearch/bleve/search/query/bool_field.go

@@ -0,0 +1,64 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+type BoolFieldQuery struct {
+	Bool     bool   `json:"bool"`
+	FieldVal string `json:"field,omitempty"`
+	BoostVal *Boost `json:"boost,omitempty"`
+}
+
+// NewBoolFieldQuery creates a new Query for boolean fields
+func NewBoolFieldQuery(val bool) *BoolFieldQuery {
+	return &BoolFieldQuery{
+		Bool: val,
+	}
+}
+
+func (q *BoolFieldQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *BoolFieldQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *BoolFieldQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *BoolFieldQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *BoolFieldQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+	term := "F"
+	if q.Bool {
+		term = "T"
+	}
+	return searcher.NewTermSearcher(i, term, field, q.BoostVal.Value(), options)
+}

vendor/github.com/blevesearch/bleve/search/query/boolean.go

@@ -0,0 +1,248 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+type BooleanQuery struct {
+	Must            Query  `json:"must,omitempty"`
+	Should          Query  `json:"should,omitempty"`
+	MustNot         Query  `json:"must_not,omitempty"`
+	BoostVal        *Boost `json:"boost,omitempty"`
+	queryStringMode bool
+}
+
+// NewBooleanQuery creates a compound Query composed
+// of several other Query objects.
+// Result documents must satisfy ALL of the
+// must Queries.
+// Result documents must satisfy NONE of the must not
+// Queries.
+// Result documents that ALSO satisfy any of the should
+// Queries will score higher.
+func NewBooleanQuery(must []Query, should []Query, mustNot []Query) *BooleanQuery {
+
+	rv := BooleanQuery{}
+	if len(must) > 0 {
+		rv.Must = NewConjunctionQuery(must)
+	}
+	if len(should) > 0 {
+		rv.Should = NewDisjunctionQuery(should)
+	}
+	if len(mustNot) > 0 {
+		rv.MustNot = NewDisjunctionQuery(mustNot)
+	}
+
+	return &rv
+}
+
+func NewBooleanQueryForQueryString(must []Query, should []Query, mustNot []Query) *BooleanQuery {
+	rv := NewBooleanQuery(nil, nil, nil)
+	rv.queryStringMode = true
+	rv.AddMust(must...)
+	rv.AddShould(should...)
+	rv.AddMustNot(mustNot...)
+	return rv
+}
+
+// SetMinShould requires that at least minShould of the
+// should Queries must be satisfied.
+func (q *BooleanQuery) SetMinShould(minShould float64) {
+	q.Should.(*DisjunctionQuery).SetMin(minShould)
+}
+
+func (q *BooleanQuery) AddMust(m ...Query) {
+	if q.Must == nil {
+		tmp := NewConjunctionQuery([]Query{})
+		tmp.queryStringMode = q.queryStringMode
+		q.Must = tmp
+	}
+	for _, mq := range m {
+		q.Must.(*ConjunctionQuery).AddQuery(mq)
+	}
+}
+
+func (q *BooleanQuery) AddShould(m ...Query) {
+	if q.Should == nil {
+		tmp := NewDisjunctionQuery([]Query{})
+		tmp.queryStringMode = q.queryStringMode
+		q.Should = tmp
+	}
+	for _, mq := range m {
+		q.Should.(*DisjunctionQuery).AddQuery(mq)
+	}
+}
+
+func (q *BooleanQuery) AddMustNot(m ...Query) {
+	if q.MustNot == nil {
+		tmp := NewDisjunctionQuery([]Query{})
+		tmp.queryStringMode = q.queryStringMode
+		q.MustNot = tmp
+	}
+	for _, mq := range m {
+		q.MustNot.(*DisjunctionQuery).AddQuery(mq)
+	}
+}
+
+func (q *BooleanQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *BooleanQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *BooleanQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	var err error
+	var mustNotSearcher search.Searcher
+	if q.MustNot != nil {
+		mustNotSearcher, err = q.MustNot.Searcher(i, m, options)
+		if err != nil {
+			return nil, err
+		}
+		// if must not is MatchNone, reset it to nil
+		if _, ok := mustNotSearcher.(*searcher.MatchNoneSearcher); ok {
+			mustNotSearcher = nil
+		}
+	}
+
+	var mustSearcher search.Searcher
+	if q.Must != nil {
+		mustSearcher, err = q.Must.Searcher(i, m, options)
+		if err != nil {
+			return nil, err
+		}
+		// if must searcher is MatchNone, reset it to nil
+		if _, ok := mustSearcher.(*searcher.MatchNoneSearcher); ok {
+			mustSearcher = nil
+		}
+	}
+
+	var shouldSearcher search.Searcher
+	if q.Should != nil {
+		shouldSearcher, err = q.Should.Searcher(i, m, options)
+		if err != nil {
+			return nil, err
+		}
+		// if should searcher is MatchNone, reset it to nil
+		if _, ok := shouldSearcher.(*searcher.MatchNoneSearcher); ok {
+			shouldSearcher = nil
+		}
+	}
+
+	// if all 3 are nil, return MatchNone
+	if mustSearcher == nil && shouldSearcher == nil && mustNotSearcher == nil {
+		return searcher.NewMatchNoneSearcher(i)
+	}
+
+	// if only mustNotSearcher, start with MatchAll
+	if mustSearcher == nil && shouldSearcher == nil && mustNotSearcher != nil {
+		mustSearcher, err = searcher.NewMatchAllSearcher(i, 1.0, options)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// optimization, if only should searcher, just return it instead
+	if mustSearcher == nil && shouldSearcher != nil && mustNotSearcher == nil {
+		return shouldSearcher, nil
+	}
+
+	return searcher.NewBooleanSearcher(i, mustSearcher, shouldSearcher, mustNotSearcher, options)
+}
+
+func (q *BooleanQuery) Validate() error {
+	if qm, ok := q.Must.(ValidatableQuery); ok {
+		err := qm.Validate()
+		if err != nil {
+			return err
+		}
+	}
+	if qs, ok := q.Should.(ValidatableQuery); ok {
+		err := qs.Validate()
+		if err != nil {
+			return err
+		}
+	}
+	if qmn, ok := q.MustNot.(ValidatableQuery); ok {
+		err := qmn.Validate()
+		if err != nil {
+			return err
+		}
+	}
+	if q.Must == nil && q.Should == nil && q.MustNot == nil {
+		return fmt.Errorf("boolean query must contain at least one must or should or not must clause")
+	}
+	return nil
+}
+
+func (q *BooleanQuery) UnmarshalJSON(data []byte) error {
+	tmp := struct {
+		Must    json.RawMessage `json:"must,omitempty"`
+		Should  json.RawMessage `json:"should,omitempty"`
+		MustNot json.RawMessage `json:"must_not,omitempty"`
+		Boost   *Boost          `json:"boost,omitempty"`
+	}{}
+	err := json.Unmarshal(data, &tmp)
+	if err != nil {
+		return err
+	}
+
+	if tmp.Must != nil {
+		q.Must, err = ParseQuery(tmp.Must)
+		if err != nil {
+			return err
+		}
+		_, isConjunctionQuery := q.Must.(*ConjunctionQuery)
+		if !isConjunctionQuery {
+			return fmt.Errorf("must clause must be conjunction")
+		}
+	}
+
+	if tmp.Should != nil {
+		q.Should, err = ParseQuery(tmp.Should)
+		if err != nil {
+			return err
+		}
+		_, isDisjunctionQuery := q.Should.(*DisjunctionQuery)
+		if !isDisjunctionQuery {
+			return fmt.Errorf("should clause must be disjunction")
+		}
+	}
+
+	if tmp.MustNot != nil {
+		q.MustNot, err = ParseQuery(tmp.MustNot)
+		if err != nil {
+			return err
+		}
+		_, isDisjunctionQuery := q.MustNot.(*DisjunctionQuery)
+		if !isDisjunctionQuery {
+			return fmt.Errorf("must not clause must be disjunction")
+		}
+	}
+
+	q.BoostVal = tmp.Boost
+
+	return nil
+}

vendor/github.com/blevesearch/bleve/search/query/boost.go

@@ -0,0 +1,33 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import "fmt"
+
+type Boost float64
+
+func (b *Boost) Value() float64 {
+	if b == nil {
+		return 1.0
+	}
+	return float64(*b)
+}
+
+func (b *Boost) GoString() string {
+	if b == nil {
+		return "boost unspecified"
+	}
+	return fmt.Sprintf("%f", *b)
+}

vendor/github.com/blevesearch/bleve/search/query/conjunction.go

@@ -0,0 +1,110 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"encoding/json"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+type ConjunctionQuery struct {
+	Conjuncts       []Query `json:"conjuncts"`
+	BoostVal        *Boost  `json:"boost,omitempty"`
+	queryStringMode bool
+}
+
+// NewConjunctionQuery creates a new compound Query.
+// Result documents must satisfy all of the queries.
+func NewConjunctionQuery(conjuncts []Query) *ConjunctionQuery {
+	return &ConjunctionQuery{
+		Conjuncts: conjuncts,
+	}
+}
+
+func (q *ConjunctionQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *ConjunctionQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *ConjunctionQuery) AddQuery(aq ...Query) {
+	for _, aaq := range aq {
+		q.Conjuncts = append(q.Conjuncts, aaq)
+	}
+}
+
+func (q *ConjunctionQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	ss := make([]search.Searcher, 0, len(q.Conjuncts))
+	for _, conjunct := range q.Conjuncts {
+		sr, err := conjunct.Searcher(i, m, options)
+		if err != nil {
+			for _, searcher := range ss {
+				if searcher != nil {
+					_ = searcher.Close()
+				}
+			}
+			return nil, err
+		}
+		if _, ok := sr.(*searcher.MatchNoneSearcher); ok && q.queryStringMode {
+			// in query string mode, skip match none
+			continue
+		}
+		ss = append(ss, sr)
+	}
+	if len(ss) < 1 {
+		return searcher.NewMatchNoneSearcher(i)
+	}
+	return searcher.NewConjunctionSearcher(i, ss, options)
+}
+
+func (q *ConjunctionQuery) Validate() error {
+	for _, q := range q.Conjuncts {
+		if q, ok := q.(ValidatableQuery); ok {
+			err := q.Validate()
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (q *ConjunctionQuery) UnmarshalJSON(data []byte) error {
+	tmp := struct {
+		Conjuncts []json.RawMessage `json:"conjuncts"`
+		Boost     *Boost            `json:"boost,omitempty"`
+	}{}
+	err := json.Unmarshal(data, &tmp)
+	if err != nil {
+		return err
+	}
+	q.Conjuncts = make([]Query, len(tmp.Conjuncts))
+	for i, term := range tmp.Conjuncts {
+		query, err := ParseQuery(term)
+		if err != nil {
+			return err
+		}
+		q.Conjuncts[i] = query
+	}
+	q.BoostVal = tmp.Boost
+	return nil
+}

vendor/github.com/blevesearch/bleve/search/query/date_range.go

@@ -0,0 +1,164 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"time"
+
+	"github.com/blevesearch/bleve/analysis/datetime/optional"
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/numeric"
+	"github.com/blevesearch/bleve/registry"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+// QueryDateTimeParser controls the default query date time parser
+var QueryDateTimeParser = optional.Name
+
+// QueryDateTimeFormat controls the format when Marshaling to JSON
+var QueryDateTimeFormat = time.RFC3339
+
+var cache = registry.NewCache()
+
+type BleveQueryTime struct {
+	time.Time
+}
+
+func queryTimeFromString(t string) (time.Time, error) {
+	dateTimeParser, err := cache.DateTimeParserNamed(QueryDateTimeParser)
+	if err != nil {
+		return time.Time{}, err
+	}
+	rv, err := dateTimeParser.ParseDateTime(t)
+	if err != nil {
+		return time.Time{}, err
+	}
+	return rv, nil
+}
+
+func (t *BleveQueryTime) MarshalJSON() ([]byte, error) {
+	tt := time.Time(t.Time)
+	return []byte("\"" + tt.Format(QueryDateTimeFormat) + "\""), nil
+}
+
+func (t *BleveQueryTime) UnmarshalJSON(data []byte) error {
+	var timeString string
+	err := json.Unmarshal(data, &timeString)
+	if err != nil {
+		return err
+	}
+	dateTimeParser, err := cache.DateTimeParserNamed(QueryDateTimeParser)
+	if err != nil {
+		return err
+	}
+	t.Time, err = dateTimeParser.ParseDateTime(timeString)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+type DateRangeQuery struct {
+	Start          BleveQueryTime `json:"start,omitempty"`
+	End            BleveQueryTime `json:"end,omitempty"`
+	InclusiveStart *bool          `json:"inclusive_start,omitempty"`
+	InclusiveEnd   *bool          `json:"inclusive_end,omitempty"`
+	FieldVal       string         `json:"field,omitempty"`
+	BoostVal       *Boost         `json:"boost,omitempty"`
+}
+
+// NewDateRangeQuery creates a new Query for ranges
+// of date values.
+// Date strings are parsed using the DateTimeParser configured in the
+//  top-level config.QueryDateTimeParser
+// Either, but not both endpoints can be nil.
+func NewDateRangeQuery(start, end time.Time) *DateRangeQuery {
+	return NewDateRangeInclusiveQuery(start, end, nil, nil)
+}
+
+// NewDateRangeInclusiveQuery creates a new Query for ranges
+// of date values.
+// Date strings are parsed using the DateTimeParser configured in the
+//  top-level config.QueryDateTimeParser
+// Either, but not both endpoints can be nil.
+// startInclusive and endInclusive control inclusion of the endpoints.
+func NewDateRangeInclusiveQuery(start, end time.Time, startInclusive, endInclusive *bool) *DateRangeQuery {
+	return &DateRangeQuery{
+		Start:          BleveQueryTime{start},
+		End:            BleveQueryTime{end},
+		InclusiveStart: startInclusive,
+		InclusiveEnd:   endInclusive,
+	}
+}
+
+func (q *DateRangeQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *DateRangeQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *DateRangeQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *DateRangeQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *DateRangeQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	min, max, err := q.parseEndpoints()
+	if err != nil {
+		return nil, err
+	}
+
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+
+	return searcher.NewNumericRangeSearcher(i, min, max, q.InclusiveStart, q.InclusiveEnd, field, q.BoostVal.Value(), options)
+}
+
+func (q *DateRangeQuery) parseEndpoints() (*float64, *float64, error) {
+	min := math.Inf(-1)
+	max := math.Inf(1)
+	if !q.Start.IsZero() {
+		min = numeric.Int64ToFloat64(q.Start.UnixNano())
+	}
+	if !q.End.IsZero() {
+		max = numeric.Int64ToFloat64(q.End.UnixNano())
+	}
+
+	return &min, &max, nil
+}
+
+func (q *DateRangeQuery) Validate() error {
+	if q.Start.IsZero() && q.End.IsZero() {
+		return fmt.Errorf("must specify start or end")
+	}
+	_, _, err := q.parseEndpoints()
+	if err != nil {
+		return err
+	}
+	return nil
+}

vendor/github.com/blevesearch/bleve/search/query/disjunction.go

@@ -0,0 +1,121 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+type DisjunctionQuery struct {
+	Disjuncts       []Query `json:"disjuncts"`
+	BoostVal        *Boost  `json:"boost,omitempty"`
+	Min             float64 `json:"min"`
+	queryStringMode bool
+}
+
+// NewDisjunctionQuery creates a new compound Query.
+// Result documents satisfy at least one Query.
+func NewDisjunctionQuery(disjuncts []Query) *DisjunctionQuery {
+	return &DisjunctionQuery{
+		Disjuncts: disjuncts,
+	}
+}
+
+func (q *DisjunctionQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *DisjunctionQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *DisjunctionQuery) AddQuery(aq ...Query) {
+	for _, aaq := range aq {
+		q.Disjuncts = append(q.Disjuncts, aaq)
+	}
+}
+
+func (q *DisjunctionQuery) SetMin(m float64) {
+	q.Min = m
+}
+
+func (q *DisjunctionQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	ss := make([]search.Searcher, 0, len(q.Disjuncts))
+	for _, disjunct := range q.Disjuncts {
+		sr, err := disjunct.Searcher(i, m, options)
+		if err != nil {
+			for _, searcher := range ss {
+				if searcher != nil {
+					_ = searcher.Close()
+				}
+			}
+			return nil, err
+		}
+		if _, ok := sr.(*searcher.MatchNoneSearcher); ok && q.queryStringMode {
+			// in query string mode, skip match none
+			continue
+		}
+		ss = append(ss, sr)
+	}
+	if len(ss) < 1 {
+		return searcher.NewMatchNoneSearcher(i)
+	}
+	return searcher.NewDisjunctionSearcher(i, ss, q.Min, options)
+}
+
+func (q *DisjunctionQuery) Validate() error {
+	if int(q.Min) > len(q.Disjuncts) {
+		return fmt.Errorf("disjunction query has fewer than the minimum number of clauses to satisfy")
+	}
+	for _, q := range q.Disjuncts {
+		if q, ok := q.(ValidatableQuery); ok {
+			err := q.Validate()
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (q *DisjunctionQuery) UnmarshalJSON(data []byte) error {
+	tmp := struct {
+		Disjuncts []json.RawMessage `json:"disjuncts"`
+		Boost     *Boost            `json:"boost,omitempty"`
+		Min       float64           `json:"min"`
+	}{}
+	err := json.Unmarshal(data, &tmp)
+	if err != nil {
+		return err
+	}
+	q.Disjuncts = make([]Query, len(tmp.Disjuncts))
+	for i, term := range tmp.Disjuncts {
+		query, err := ParseQuery(term)
+		if err != nil {
+			return err
+		}
+		q.Disjuncts[i] = query
+	}
+	q.BoostVal = tmp.Boost
+	q.Min = tmp.Min
+	return nil
+}

vendor/github.com/blevesearch/bleve/search/query/docid.go

@@ -0,0 +1,49 @@
+//  Copyright (c) 2015 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+type DocIDQuery struct {
+	IDs      []string `json:"ids"`
+	BoostVal *Boost   `json:"boost,omitempty"`
+}
+
+// NewDocIDQuery creates a new Query object returning indexed documents among
+// the specified set. Combine it with ConjunctionQuery to restrict the scope of
+// other queries output.
+func NewDocIDQuery(ids []string) *DocIDQuery {
+	return &DocIDQuery{
+		IDs: ids,
+	}
+}
+
+func (q *DocIDQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *DocIDQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *DocIDQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	return searcher.NewDocIDSearcher(i, q.IDs, q.BoostVal.Value(), options)
+}

vendor/github.com/blevesearch/bleve/search/query/fuzzy.go

@@ -0,0 +1,77 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+type FuzzyQuery struct {
+	Term      string `json:"term"`
+	Prefix    int    `json:"prefix_length"`
+	Fuzziness int    `json:"fuzziness"`
+	FieldVal  string `json:"field,omitempty"`
+	BoostVal  *Boost `json:"boost,omitempty"`
+}
+
+// NewFuzzyQuery creates a new Query which finds
+// documents containing terms within a specific
+// fuzziness of the specified term.
+// The default fuzziness is 1.
+//
+// The current implementation uses Levenshtein edit
+// distance as the fuzziness metric.
+func NewFuzzyQuery(term string) *FuzzyQuery {
+	return &FuzzyQuery{
+		Term:      term,
+		Fuzziness: 1,
+	}
+}
+
+func (q *FuzzyQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *FuzzyQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *FuzzyQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *FuzzyQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *FuzzyQuery) SetFuzziness(f int) {
+	q.Fuzziness = f
+}
+
+func (q *FuzzyQuery) SetPrefix(p int) {
+	q.Prefix = p
+}
+
+func (q *FuzzyQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+	return searcher.NewFuzzySearcher(i, q.Term, q.Prefix, q.Fuzziness, field, q.BoostVal.Value(), options)
+}

vendor/github.com/blevesearch/bleve/search/query/geo_boundingbox.go

@@ -0,0 +1,113 @@
+//  Copyright (c) 2017 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/blevesearch/bleve/geo"
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+type GeoBoundingBoxQuery struct {
+	TopLeft     []float64 `json:"top_left,omitempty"`
+	BottomRight []float64 `json:"bottom_right,omitempty"`
+	FieldVal    string    `json:"field,omitempty"`
+	BoostVal    *Boost    `json:"boost,omitempty"`
+}
+
+func NewGeoBoundingBoxQuery(topLeftLon, topLeftLat, bottomRightLon, bottomRightLat float64) *GeoBoundingBoxQuery {
+	return &GeoBoundingBoxQuery{
+		TopLeft:     []float64{topLeftLon, topLeftLat},
+		BottomRight: []float64{bottomRightLon, bottomRightLat},
+	}
+}
+
+func (q *GeoBoundingBoxQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *GeoBoundingBoxQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *GeoBoundingBoxQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *GeoBoundingBoxQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *GeoBoundingBoxQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+
+	if q.BottomRight[0] < q.TopLeft[0] {
+		// cross date line, rewrite as two parts
+
+		leftSearcher, err := searcher.NewGeoBoundingBoxSearcher(i, -180, q.BottomRight[1], q.BottomRight[0], q.TopLeft[1], field, q.BoostVal.Value(), options, true)
+		if err != nil {
+			return nil, err
+		}
+		rightSearcher, err := searcher.NewGeoBoundingBoxSearcher(i, q.TopLeft[0], q.BottomRight[1], 180, q.TopLeft[1], field, q.BoostVal.Value(), options, true)
+		if err != nil {
+			_ = leftSearcher.Close()
+			return nil, err
+		}
+
+		return searcher.NewDisjunctionSearcher(i, []search.Searcher{leftSearcher, rightSearcher}, 0, options)
+	}
+
+	return searcher.NewGeoBoundingBoxSearcher(i, q.TopLeft[0], q.BottomRight[1], q.BottomRight[0], q.TopLeft[1], field, q.BoostVal.Value(), options, true)
+}
+
+func (q *GeoBoundingBoxQuery) Validate() error {
+	return nil
+}
+
+func (q *GeoBoundingBoxQuery) UnmarshalJSON(data []byte) error {
+	tmp := struct {
+		TopLeft     interface{} `json:"top_left,omitempty"`
+		BottomRight interface{} `json:"bottom_right,omitempty"`
+		FieldVal    string      `json:"field,omitempty"`
+		BoostVal    *Boost      `json:"boost,omitempty"`
+	}{}
+	err := json.Unmarshal(data, &tmp)
+	if err != nil {
+		return err
+	}
+	// now use our generic point parsing code from the geo package
+	lon, lat, found := geo.ExtractGeoPoint(tmp.TopLeft)
+	if !found {
+		return fmt.Errorf("geo location top_left not in a valid format")
+	}
+	q.TopLeft = []float64{lon, lat}
+	lon, lat, found = geo.ExtractGeoPoint(tmp.BottomRight)
+	if !found {
+		return fmt.Errorf("geo location bottom_right not in a valid format")
+	}
+	q.BottomRight = []float64{lon, lat}
+	q.FieldVal = tmp.FieldVal
+	q.BoostVal = tmp.BoostVal
+	return nil
+}

vendor/github.com/blevesearch/bleve/search/query/geo_distance.go

@@ -0,0 +1,100 @@
+//  Copyright (c) 2017 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/blevesearch/bleve/geo"
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+type GeoDistanceQuery struct {
+	Location []float64 `json:"location,omitempty"`
+	Distance string    `json:"distance,omitempty"`
+	FieldVal string    `json:"field,omitempty"`
+	BoostVal *Boost    `json:"boost,omitempty"`
+}
+
+func NewGeoDistanceQuery(lon, lat float64, distance string) *GeoDistanceQuery {
+	return &GeoDistanceQuery{
+		Location: []float64{lon, lat},
+		Distance: distance,
+	}
+}
+
+func (q *GeoDistanceQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *GeoDistanceQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *GeoDistanceQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *GeoDistanceQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *GeoDistanceQuery) Searcher(i index.IndexReader, m mapping.IndexMapping,
+	options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+
+	dist, err := geo.ParseDistance(q.Distance)
+	if err != nil {
+		return nil, err
+	}
+
+	return searcher.NewGeoPointDistanceSearcher(i, q.Location[0], q.Location[1],
+		dist, field, q.BoostVal.Value(), options)
+}
+
+func (q *GeoDistanceQuery) Validate() error {
+	return nil
+}
+
+func (q *GeoDistanceQuery) UnmarshalJSON(data []byte) error {
+	tmp := struct {
+		Location interface{} `json:"location,omitempty"`
+		Distance string      `json:"distance,omitempty"`
+		FieldVal string      `json:"field,omitempty"`
+		BoostVal *Boost      `json:"boost,omitempty"`
+	}{}
+	err := json.Unmarshal(data, &tmp)
+	if err != nil {
+		return err
+	}
+	// now use our generic point parsing code from the geo package
+	lon, lat, found := geo.ExtractGeoPoint(tmp.Location)
+	if !found {
+		return fmt.Errorf("geo location not in a valid format")
+	}
+	q.Location = []float64{lon, lat}
+	q.Distance = tmp.Distance
+	q.FieldVal = tmp.FieldVal
+	q.BoostVal = tmp.BoostVal
+	return nil
+}

vendor/github.com/blevesearch/bleve/search/query/match.go

@@ -0,0 +1,176 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+)
+
+type MatchQuery struct {
+	Match     string             `json:"match"`
+	FieldVal  string             `json:"field,omitempty"`
+	Analyzer  string             `json:"analyzer,omitempty"`
+	BoostVal  *Boost             `json:"boost,omitempty"`
+	Prefix    int                `json:"prefix_length"`
+	Fuzziness int                `json:"fuzziness"`
+	Operator  MatchQueryOperator `json:"operator,omitempty"`
+}
+
+type MatchQueryOperator int
+
+const (
+	// Document must satisfy AT LEAST ONE of term searches.
+	MatchQueryOperatorOr = 0
+	// Document must satisfy ALL of term searches.
+	MatchQueryOperatorAnd = 1
+)
+
+func (o MatchQueryOperator) MarshalJSON() ([]byte, error) {
+	switch o {
+	case MatchQueryOperatorOr:
+		return json.Marshal("or")
+	case MatchQueryOperatorAnd:
+		return json.Marshal("and")
+	default:
+		return nil, fmt.Errorf("cannot marshal match operator %d to JSON", o)
+	}
+}
+
+func (o *MatchQueryOperator) UnmarshalJSON(data []byte) error {
+	var operatorString string
+	err := json.Unmarshal(data, &operatorString)
+	if err != nil {
+		return err
+	}
+
+	switch operatorString {
+	case "or":
+		*o = MatchQueryOperatorOr
+		return nil
+	case "and":
+		*o = MatchQueryOperatorAnd
+		return nil
+	default:
+		return fmt.Errorf("cannot unmarshal match operator '%v' from JSON", o)
+	}
+}
+
+// NewMatchQuery creates a Query for matching text.
+// An Analyzer is chosen based on the field.
+// Input text is analyzed using this analyzer.
+// Token terms resulting from this analysis are
+// used to perform term searches.  Result documents
+// must satisfy at least one of these term searches.
+func NewMatchQuery(match string) *MatchQuery {
+	return &MatchQuery{
+		Match:    match,
+		Operator: MatchQueryOperatorOr,
+	}
+}
+
+func (q *MatchQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *MatchQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *MatchQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *MatchQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *MatchQuery) SetFuzziness(f int) {
+	q.Fuzziness = f
+}
+
+func (q *MatchQuery) SetPrefix(p int) {
+	q.Prefix = p
+}
+
+func (q *MatchQuery) SetOperator(operator MatchQueryOperator) {
+	q.Operator = operator
+}
+
+func (q *MatchQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+
+	analyzerName := ""
+	if q.Analyzer != "" {
+		analyzerName = q.Analyzer
+	} else {
+		analyzerName = m.AnalyzerNameForPath(field)
+	}
+	analyzer := m.AnalyzerNamed(analyzerName)
+
+	if analyzer == nil {
+		return nil, fmt.Errorf("no analyzer named '%s' registered", q.Analyzer)
+	}
+
+	tokens := analyzer.Analyze([]byte(q.Match))
+	if len(tokens) > 0 {
+
+		tqs := make([]Query, len(tokens))
+		if q.Fuzziness != 0 {
+			for i, token := range tokens {
+				query := NewFuzzyQuery(string(token.Term))
+				query.SetFuzziness(q.Fuzziness)
+				query.SetPrefix(q.Prefix)
+				query.SetField(field)
+				query.SetBoost(q.BoostVal.Value())
+				tqs[i] = query
+			}
+		} else {
+			for i, token := range tokens {
+				tq := NewTermQuery(string(token.Term))
+				tq.SetField(field)
+				tq.SetBoost(q.BoostVal.Value())
+				tqs[i] = tq
+			}
+		}
+
+		switch q.Operator {
+		case MatchQueryOperatorOr:
+			shouldQuery := NewDisjunctionQuery(tqs)
+			shouldQuery.SetMin(1)
+			shouldQuery.SetBoost(q.BoostVal.Value())
+			return shouldQuery.Searcher(i, m, options)
+
+		case MatchQueryOperatorAnd:
+			mustQuery := NewConjunctionQuery(tqs)
+			mustQuery.SetBoost(q.BoostVal.Value())
+			return mustQuery.Searcher(i, m, options)
+
+		default:
+			return nil, fmt.Errorf("unhandled operator %d", q.Operator)
+		}
+	}
+	noneQuery := NewMatchNoneQuery()
+	return noneQuery.Searcher(i, m, options)
+}

vendor/github.com/blevesearch/bleve/search/query/match_all.go

@@ -0,0 +1,55 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"encoding/json"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+type MatchAllQuery struct {
+	BoostVal *Boost `json:"boost,omitempty"`
+}
+
+// NewMatchAllQuery creates a Query which will
+// match all documents in the index.
+func NewMatchAllQuery() *MatchAllQuery {
+	return &MatchAllQuery{}
+}
+
+func (q *MatchAllQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *MatchAllQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *MatchAllQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	return searcher.NewMatchAllSearcher(i, q.BoostVal.Value(), options)
+}
+
+func (q *MatchAllQuery) MarshalJSON() ([]byte, error) {
+	tmp := map[string]interface{}{
+		"boost":     q.BoostVal,
+		"match_all": map[string]interface{}{},
+	}
+	return json.Marshal(tmp)
+}

vendor/github.com/blevesearch/bleve/search/query/match_none.go

@@ -0,0 +1,55 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"encoding/json"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+type MatchNoneQuery struct {
+	BoostVal *Boost `json:"boost,omitempty"`
+}
+
+// NewMatchNoneQuery creates a Query which will not
+// match any documents in the index.
+func NewMatchNoneQuery() *MatchNoneQuery {
+	return &MatchNoneQuery{}
+}
+
+func (q *MatchNoneQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *MatchNoneQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *MatchNoneQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	return searcher.NewMatchNoneSearcher(i)
+}
+
+func (q *MatchNoneQuery) MarshalJSON() ([]byte, error) {
+	tmp := map[string]interface{}{
+		"boost":      q.BoostVal,
+		"match_none": map[string]interface{}{},
+	}
+	return json.Marshal(tmp)
+}

vendor/github.com/blevesearch/bleve/search/query/match_phrase.go

@@ -0,0 +1,113 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"fmt"
+
+	"github.com/blevesearch/bleve/analysis"
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+)
+
+type MatchPhraseQuery struct {
+	MatchPhrase string `json:"match_phrase"`
+	FieldVal    string `json:"field,omitempty"`
+	Analyzer    string `json:"analyzer,omitempty"`
+	BoostVal    *Boost `json:"boost,omitempty"`
+}
+
+// NewMatchPhraseQuery creates a new Query object
+// for matching phrases in the index.
+// An Analyzer is chosen based on the field.
+// Input text is analyzed using this analyzer.
+// Token terms resulting from this analysis are
+// used to build a search phrase.  Result documents
+// must match this phrase. Queried field must have been indexed with
+// IncludeTermVectors set to true.
+func NewMatchPhraseQuery(matchPhrase string) *MatchPhraseQuery {
+	return &MatchPhraseQuery{
+		MatchPhrase: matchPhrase,
+	}
+}
+
+func (q *MatchPhraseQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *MatchPhraseQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *MatchPhraseQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *MatchPhraseQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *MatchPhraseQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+
+	analyzerName := ""
+	if q.Analyzer != "" {
+		analyzerName = q.Analyzer
+	} else {
+		analyzerName = m.AnalyzerNameForPath(field)
+	}
+	analyzer := m.AnalyzerNamed(analyzerName)
+	if analyzer == nil {
+		return nil, fmt.Errorf("no analyzer named '%s' registered", q.Analyzer)
+	}
+
+	tokens := analyzer.Analyze([]byte(q.MatchPhrase))
+	if len(tokens) > 0 {
+		phrase := tokenStreamToPhrase(tokens)
+		phraseQuery := NewMultiPhraseQuery(phrase, field)
+		phraseQuery.SetBoost(q.BoostVal.Value())
+		return phraseQuery.Searcher(i, m, options)
+	}
+	noneQuery := NewMatchNoneQuery()
+	return noneQuery.Searcher(i, m, options)
+}
+
+func tokenStreamToPhrase(tokens analysis.TokenStream) [][]string {
+	firstPosition := int(^uint(0) >> 1)
+	lastPosition := 0
+	for _, token := range tokens {
+		if token.Position < firstPosition {
+			firstPosition = token.Position
+		}
+		if token.Position > lastPosition {
+			lastPosition = token.Position
+		}
+	}
+	phraseLen := lastPosition - firstPosition + 1
+	if phraseLen > 0 {
+		rv := make([][]string, phraseLen)
+		for _, token := range tokens {
+			pos := token.Position - firstPosition
+			rv[pos] = append(rv[pos], string(token.Term))
+		}
+		return rv
+	}
+	return nil
+}

vendor/github.com/blevesearch/bleve/search/query/multi_phrase.go

@@ -0,0 +1,80 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+type MultiPhraseQuery struct {
+	Terms    [][]string `json:"terms"`
+	Field    string     `json:"field,omitempty"`
+	BoostVal *Boost     `json:"boost,omitempty"`
+}
+
+// NewMultiPhraseQuery creates a new Query for finding
+// term phrases in the index.
+// It is like PhraseQuery, but each position in the
+// phrase may be satisfied by a list of terms
+// as opposed to just one.
+// At least one of the terms must exist in the correct
+// order, at the correct index offsets, in the
+// specified field. Queried field must have been indexed with
+// IncludeTermVectors set to true.
+func NewMultiPhraseQuery(terms [][]string, field string) *MultiPhraseQuery {
+	return &MultiPhraseQuery{
+		Terms: terms,
+		Field: field,
+	}
+}
+
+func (q *MultiPhraseQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *MultiPhraseQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *MultiPhraseQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	return searcher.NewMultiPhraseSearcher(i, q.Terms, q.Field, options)
+}
+
+func (q *MultiPhraseQuery) Validate() error {
+	if len(q.Terms) < 1 {
+		return fmt.Errorf("phrase query must contain at least one term")
+	}
+	return nil
+}
+
+func (q *MultiPhraseQuery) UnmarshalJSON(data []byte) error {
+	type _mphraseQuery MultiPhraseQuery
+	tmp := _mphraseQuery{}
+	err := json.Unmarshal(data, &tmp)
+	if err != nil {
+		return err
+	}
+	q.Terms = tmp.Terms
+	q.Field = tmp.Field
+	q.BoostVal = tmp.BoostVal
+	return nil
+}

vendor/github.com/blevesearch/bleve/search/query/numeric_range.go

@@ -0,0 +1,87 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"fmt"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+type NumericRangeQuery struct {
+	Min          *float64 `json:"min,omitempty"`
+	Max          *float64 `json:"max,omitempty"`
+	InclusiveMin *bool    `json:"inclusive_min,omitempty"`
+	InclusiveMax *bool    `json:"inclusive_max,omitempty"`
+	FieldVal     string   `json:"field,omitempty"`
+	BoostVal     *Boost   `json:"boost,omitempty"`
+}
+
+// NewNumericRangeQuery creates a new Query for ranges
+// of numeric values.
+// Either, but not both endpoints can be nil.
+// The minimum value is inclusive.
+// The maximum value is exclusive.
+func NewNumericRangeQuery(min, max *float64) *NumericRangeQuery {
+	return NewNumericRangeInclusiveQuery(min, max, nil, nil)
+}
+
+// NewNumericRangeInclusiveQuery creates a new Query for ranges
+// of numeric values.
+// Either, but not both endpoints can be nil.
+// Control endpoint inclusion with inclusiveMin, inclusiveMax.
+func NewNumericRangeInclusiveQuery(min, max *float64, minInclusive, maxInclusive *bool) *NumericRangeQuery {
+	return &NumericRangeQuery{
+		Min:          min,
+		Max:          max,
+		InclusiveMin: minInclusive,
+		InclusiveMax: maxInclusive,
+	}
+}
+
+func (q *NumericRangeQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *NumericRangeQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *NumericRangeQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *NumericRangeQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *NumericRangeQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+	return searcher.NewNumericRangeSearcher(i, q.Min, q.Max, q.InclusiveMin, q.InclusiveMax, field, q.BoostVal.Value(), options)
+}
+
+func (q *NumericRangeQuery) Validate() error {
+	if q.Min == nil && q.Min == q.Max {
+		return fmt.Errorf("numeric range query must specify min or max")
+	}
+	return nil
+}

vendor/github.com/blevesearch/bleve/search/query/phrase.go

@@ -0,0 +1,77 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+type PhraseQuery struct {
+	Terms    []string `json:"terms"`
+	Field    string   `json:"field,omitempty"`
+	BoostVal *Boost   `json:"boost,omitempty"`
+}
+
+// NewPhraseQuery creates a new Query for finding
+// exact term phrases in the index.
+// The provided terms must exist in the correct
+// order, at the correct index offsets, in the
+// specified field. Queried field must have been indexed with
+// IncludeTermVectors set to true.
+func NewPhraseQuery(terms []string, field string) *PhraseQuery {
+	return &PhraseQuery{
+		Terms: terms,
+		Field: field,
+	}
+}
+
+func (q *PhraseQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *PhraseQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *PhraseQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	return searcher.NewPhraseSearcher(i, q.Terms, q.Field, options)
+}
+
+func (q *PhraseQuery) Validate() error {
+	if len(q.Terms) < 1 {
+		return fmt.Errorf("phrase query must contain at least one term")
+	}
+	return nil
+}
+
+func (q *PhraseQuery) UnmarshalJSON(data []byte) error {
+	type _phraseQuery PhraseQuery
+	tmp := _phraseQuery{}
+	err := json.Unmarshal(data, &tmp)
+	if err != nil {
+		return err
+	}
+	q.Terms = tmp.Terms
+	q.Field = tmp.Field
+	q.BoostVal = tmp.BoostVal
+	return nil
+}

vendor/github.com/blevesearch/bleve/search/query/prefix.go

@@ -0,0 +1,62 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+type PrefixQuery struct {
+	Prefix   string `json:"prefix"`
+	FieldVal string `json:"field,omitempty"`
+	BoostVal *Boost `json:"boost,omitempty"`
+}
+
+// NewPrefixQuery creates a new Query which finds
+// documents containing terms that start with the
+// specified prefix.
+func NewPrefixQuery(prefix string) *PrefixQuery {
+	return &PrefixQuery{
+		Prefix: prefix,
+	}
+}
+
+func (q *PrefixQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *PrefixQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *PrefixQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *PrefixQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *PrefixQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+	return searcher.NewTermPrefixSearcher(i, q.Prefix, field, q.BoostVal.Value(), options)
+}

vendor/github.com/blevesearch/bleve/search/query/query.go

@@ -0,0 +1,356 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+)
+
+var logger = log.New(ioutil.Discard, "bleve mapping ", log.LstdFlags)
+
+// SetLog sets the logger used for logging
+// by default log messages are sent to ioutil.Discard
+func SetLog(l *log.Logger) {
+	logger = l
+}
+
+// A Query represents a description of the type
+// and parameters for a query into the index.
+type Query interface {
+	Searcher(i index.IndexReader, m mapping.IndexMapping,
+		options search.SearcherOptions) (search.Searcher, error)
+}
+
+// A BoostableQuery represents a Query which can be boosted
+// relative to other queries.
+type BoostableQuery interface {
+	Query
+	SetBoost(b float64)
+	Boost() float64
+}
+
+// A FieldableQuery represents a Query which can be restricted
+// to a single field.
+type FieldableQuery interface {
+	Query
+	SetField(f string)
+	Field() string
+}
+
+// A ValidatableQuery represents a Query which can be validated
+// prior to execution.
+type ValidatableQuery interface {
+	Query
+	Validate() error
+}
+
+// ParseQuery deserializes a JSON representation of
+// a Query object.
+func ParseQuery(input []byte) (Query, error) {
+	var tmp map[string]interface{}
+	err := json.Unmarshal(input, &tmp)
+	if err != nil {
+		return nil, err
+	}
+	_, isMatchQuery := tmp["match"]
+	_, hasFuzziness := tmp["fuzziness"]
+	if hasFuzziness && !isMatchQuery {
+		var rv FuzzyQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, isTermQuery := tmp["term"]
+	if isTermQuery {
+		var rv TermQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	if isMatchQuery {
+		var rv MatchQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, isMatchPhraseQuery := tmp["match_phrase"]
+	if isMatchPhraseQuery {
+		var rv MatchPhraseQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasMust := tmp["must"]
+	_, hasShould := tmp["should"]
+	_, hasMustNot := tmp["must_not"]
+	if hasMust || hasShould || hasMustNot {
+		var rv BooleanQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasTerms := tmp["terms"]
+	if hasTerms {
+		var rv PhraseQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			// now try multi-phrase
+			var rv2 MultiPhraseQuery
+			err = json.Unmarshal(input, &rv2)
+			if err != nil {
+				return nil, err
+			}
+			return &rv2, nil
+		}
+		return &rv, nil
+	}
+	_, hasConjuncts := tmp["conjuncts"]
+	if hasConjuncts {
+		var rv ConjunctionQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasDisjuncts := tmp["disjuncts"]
+	if hasDisjuncts {
+		var rv DisjunctionQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+
+	_, hasSyntaxQuery := tmp["query"]
+	if hasSyntaxQuery {
+		var rv QueryStringQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasMin := tmp["min"].(float64)
+	_, hasMax := tmp["max"].(float64)
+	if hasMin || hasMax {
+		var rv NumericRangeQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasMinStr := tmp["min"].(string)
+	_, hasMaxStr := tmp["max"].(string)
+	if hasMinStr || hasMaxStr {
+		var rv TermRangeQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasStart := tmp["start"]
+	_, hasEnd := tmp["end"]
+	if hasStart || hasEnd {
+		var rv DateRangeQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasPrefix := tmp["prefix"]
+	if hasPrefix {
+		var rv PrefixQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasRegexp := tmp["regexp"]
+	if hasRegexp {
+		var rv RegexpQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasWildcard := tmp["wildcard"]
+	if hasWildcard {
+		var rv WildcardQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasMatchAll := tmp["match_all"]
+	if hasMatchAll {
+		var rv MatchAllQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasMatchNone := tmp["match_none"]
+	if hasMatchNone {
+		var rv MatchNoneQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasDocIds := tmp["ids"]
+	if hasDocIds {
+		var rv DocIDQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasBool := tmp["bool"]
+	if hasBool {
+		var rv BoolFieldQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasTopLeft := tmp["top_left"]
+	_, hasBottomRight := tmp["bottom_right"]
+	if hasTopLeft && hasBottomRight {
+		var rv GeoBoundingBoxQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasDistance := tmp["distance"]
+	if hasDistance {
+		var rv GeoDistanceQuery
+		err := json.Unmarshal(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	return nil, fmt.Errorf("unknown query type")
+}
+
+// expandQuery traverses the input query tree and returns a new tree where
+// query string queries have been expanded into base queries. Returned tree may
+// reference queries from the input tree or new queries.
+func expandQuery(m mapping.IndexMapping, query Query) (Query, error) {
+	var expand func(query Query) (Query, error)
+	var expandSlice func(queries []Query) ([]Query, error)
+
+	expandSlice = func(queries []Query) ([]Query, error) {
+		expanded := []Query{}
+		for _, q := range queries {
+			exp, err := expand(q)
+			if err != nil {
+				return nil, err
+			}
+			expanded = append(expanded, exp)
+		}
+		return expanded, nil
+	}
+
+	expand = func(query Query) (Query, error) {
+		switch query.(type) {
+		case *QueryStringQuery:
+			q := query.(*QueryStringQuery)
+			parsed, err := parseQuerySyntax(q.Query)
+			if err != nil {
+				return nil, fmt.Errorf("could not parse '%s': %s", q.Query, err)
+			}
+			return expand(parsed)
+		case *ConjunctionQuery:
+			q := *query.(*ConjunctionQuery)
+			children, err := expandSlice(q.Conjuncts)
+			if err != nil {
+				return nil, err
+			}
+			q.Conjuncts = children
+			return &q, nil
+		case *DisjunctionQuery:
+			q := *query.(*DisjunctionQuery)
+			children, err := expandSlice(q.Disjuncts)
+			if err != nil {
+				return nil, err
+			}
+			q.Disjuncts = children
+			return &q, nil
+		case *BooleanQuery:
+			q := *query.(*BooleanQuery)
+			var err error
+			q.Must, err = expand(q.Must)
+			if err != nil {
+				return nil, err
+			}
+			q.Should, err = expand(q.Should)
+			if err != nil {
+				return nil, err
+			}
+			q.MustNot, err = expand(q.MustNot)
+			if err != nil {
+				return nil, err
+			}
+			return &q, nil
+		default:
+			return query, nil
+		}
+	}
+	return expand(query)
+}
+
+// DumpQuery returns a string representation of the query tree, where query
+// string queries have been expanded into base queries. The output format is
+// meant for debugging purpose and may change in the future.
+func DumpQuery(m mapping.IndexMapping, query Query) (string, error) {
+	q, err := expandQuery(m, query)
+	if err != nil {
+		return "", err
+	}
+	data, err := json.MarshalIndent(q, "", "  ")
+	return string(data), err
+}

vendor/github.com/blevesearch/bleve/search/query/query_string.go

@@ -0,0 +1,63 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+)
+
+type QueryStringQuery struct {
+	Query    string `json:"query"`
+	BoostVal *Boost `json:"boost,omitempty"`
+}
+
+// NewQueryStringQuery creates a new Query used for
+// finding documents that satisfy a query string.  The
+// query string is a small query language for humans.
+func NewQueryStringQuery(query string) *QueryStringQuery {
+	return &QueryStringQuery{
+		Query: query,
+	}
+}
+
+func (q *QueryStringQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *QueryStringQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *QueryStringQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	newQuery, err := parseQuerySyntax(q.Query)
+	if err != nil {
+		return nil, err
+	}
+	return newQuery.Searcher(i, m, options)
+}
+
+func (q *QueryStringQuery) Validate() error {
+	newQuery, err := parseQuerySyntax(q.Query)
+	if err != nil {
+		return err
+	}
+	if newQuery, ok := newQuery.(ValidatableQuery); ok {
+		return newQuery.Validate()
+	}
+	return nil
+}

vendor/github.com/blevesearch/bleve/search/query/query_string.y

@@ -0,0 +1,328 @@
+%{
+package query
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func logDebugGrammar(format string, v ...interface{}) {
+	if debugParser {
+    	logger.Printf(format, v...)
+    }
+}
+%}
+
+%union {
+s string
+n int
+f float64
+q Query
+pf *float64}
+
+%token tSTRING tPHRASE tPLUS tMINUS tCOLON tBOOST tNUMBER tSTRING tGREATER tLESS
+tEQUAL tTILDE
+
+%type <s>                tSTRING
+%type <s>                tPHRASE
+%type <s>                tNUMBER
+%type <s>                posOrNegNumber
+%type <s>                tTILDE
+%type <s>                tBOOST
+%type <q>                searchBase
+%type <pf>                searchSuffix
+%type <n>                searchPrefix
+
+%%
+
+input:
+searchParts {
+	logDebugGrammar("INPUT")
+};
+
+searchParts:
+searchPart searchParts {
+	logDebugGrammar("SEARCH PARTS")
+}
+|
+searchPart {
+	logDebugGrammar("SEARCH PART")
+};
+
+searchPart:
+searchPrefix searchBase searchSuffix {
+	query := $2
+	if $3 != nil {
+		if query, ok := query.(BoostableQuery); ok {
+			query.SetBoost(*$3)
+			}
+	}
+	switch($1) {
+		case queryShould:
+			yylex.(*lexerWrapper).query.AddShould(query)
+		case queryMust:
+			yylex.(*lexerWrapper).query.AddMust(query)
+		case queryMustNot:
+			yylex.(*lexerWrapper).query.AddMustNot(query)
+	}
+};
+
+
+searchPrefix:
+/* empty */ {
+	$$ = queryShould
+}
+|
+tPLUS {
+	logDebugGrammar("PLUS")
+	$$ = queryMust
+}
+|
+tMINUS {
+	logDebugGrammar("MINUS")
+	$$ = queryMustNot
+};
+
+searchBase:
+tSTRING {
+	str := $1
+	logDebugGrammar("STRING - %s", str)
+	var q FieldableQuery
+	if strings.HasPrefix(str, "/") && strings.HasSuffix(str, "/") {
+	  q = NewRegexpQuery(str[1:len(str)-1])
+	} else if strings.ContainsAny(str, "*?"){
+	  q = NewWildcardQuery(str)
+	} else {
+	  q = NewMatchQuery(str)
+	}
+	$$ = q
+}
+|
+tSTRING tTILDE {
+	str := $1
+	fuzziness, err := strconv.ParseFloat($2, 64)
+	if err != nil {
+	  yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid fuzziness value: %v", err))
+	}
+	logDebugGrammar("FUZZY STRING - %s %f", str, fuzziness)
+	q := NewMatchQuery(str)
+	q.SetFuzziness(int(fuzziness))
+	$$ = q
+}
+|
+tSTRING tCOLON tSTRING tTILDE {
+	field := $1
+	str := $3
+	fuzziness, err := strconv.ParseFloat($4, 64)
+	if err != nil {
+		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid fuzziness value: %v", err))
+	}
+	logDebugGrammar("FIELD - %s FUZZY STRING - %s %f", field, str, fuzziness)
+	q := NewMatchQuery(str)
+	q.SetFuzziness(int(fuzziness))
+	q.SetField(field)
+	$$ = q
+}
+|
+tNUMBER {
+	str := $1
+	logDebugGrammar("STRING - %s", str)
+	q1 := NewMatchQuery(str)
+	val, err := strconv.ParseFloat($1, 64)
+	if err != nil {
+		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
+	}
+	inclusive := true
+	q2 := NewNumericRangeInclusiveQuery(&val, &val, &inclusive, &inclusive)
+	q := NewDisjunctionQuery([]Query{q1,q2})
+	q.queryStringMode = true
+	$$ = q
+}
+|
+tPHRASE {
+	phrase := $1
+	logDebugGrammar("PHRASE - %s", phrase)
+	q := NewMatchPhraseQuery(phrase)
+	$$ = q
+}
+|
+tSTRING tCOLON tSTRING {
+	field := $1
+	str := $3
+	logDebugGrammar("FIELD - %s STRING - %s", field, str)
+	var q FieldableQuery
+	if strings.HasPrefix(str, "/") && strings.HasSuffix(str, "/") {
+		q = NewRegexpQuery(str[1:len(str)-1])
+	} else if strings.ContainsAny(str, "*?"){
+	  q = NewWildcardQuery(str)
+	}  else {
+		q = NewMatchQuery(str)
+	}
+	q.SetField(field)
+	$$ = q
+}
+|
+tSTRING tCOLON posOrNegNumber {
+	field := $1
+	str := $3
+	logDebugGrammar("FIELD - %s STRING - %s", field, str)
+	q1 := NewMatchQuery(str)
+	q1.SetField(field)
+	val, err := strconv.ParseFloat($3, 64)
+	if err != nil {
+		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
+	}
+	inclusive := true
+	q2 := NewNumericRangeInclusiveQuery(&val, &val, &inclusive, &inclusive)
+	q2.SetField(field)
+	q := NewDisjunctionQuery([]Query{q1,q2})
+	q.queryStringMode = true
+	$$ = q
+}
+|
+tSTRING tCOLON tPHRASE {
+	field := $1
+	phrase := $3
+	logDebugGrammar("FIELD - %s PHRASE - %s", field, phrase)
+	q := NewMatchPhraseQuery(phrase)
+	q.SetField(field)
+	$$ = q
+}
+|
+tSTRING tCOLON tGREATER posOrNegNumber {
+	field := $1
+	min, err := strconv.ParseFloat($4, 64)
+	if err != nil {
+		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
+	}
+	minInclusive := false
+	logDebugGrammar("FIELD - GREATER THAN %f", min)
+	q := NewNumericRangeInclusiveQuery(&min, nil, &minInclusive, nil)
+	q.SetField(field)
+	$$ = q
+}
+|
+tSTRING tCOLON tGREATER tEQUAL posOrNegNumber {
+	field := $1
+	min, err := strconv.ParseFloat($5, 64)
+	if err != nil {
+		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
+	}
+	minInclusive := true
+	logDebugGrammar("FIELD - GREATER THAN OR EQUAL %f", min)
+	q := NewNumericRangeInclusiveQuery(&min, nil, &minInclusive, nil)
+	q.SetField(field)
+	$$ = q
+}
+|
+tSTRING tCOLON tLESS posOrNegNumber {
+	field := $1
+	max, err := strconv.ParseFloat($4, 64)
+	if err != nil {
+		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
+	}
+	maxInclusive := false
+	logDebugGrammar("FIELD - LESS THAN %f", max)
+	q := NewNumericRangeInclusiveQuery(nil, &max, nil, &maxInclusive)
+	q.SetField(field)
+	$$ = q
+}
+|
+tSTRING tCOLON tLESS tEQUAL posOrNegNumber {
+	field := $1
+	max, err := strconv.ParseFloat($5, 64)
+	if err != nil {
+		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
+	}
+	maxInclusive := true
+	logDebugGrammar("FIELD - LESS THAN OR EQUAL %f", max)
+	q := NewNumericRangeInclusiveQuery(nil, &max, nil, &maxInclusive)
+	q.SetField(field)
+	$$ = q
+}
+|
+tSTRING tCOLON tGREATER tPHRASE {
+	field := $1
+	minInclusive := false
+	phrase := $4
+
+	logDebugGrammar("FIELD - GREATER THAN DATE %s", phrase)
+	minTime, err := queryTimeFromString(phrase)
+	if err != nil {
+	  yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
+	}
+	q := NewDateRangeInclusiveQuery(minTime, time.Time{}, &minInclusive, nil)
+	q.SetField(field)
+	$$ = q
+}
+|
+tSTRING tCOLON tGREATER tEQUAL tPHRASE {
+	field := $1
+	minInclusive := true
+	phrase := $5
+
+	logDebugGrammar("FIELD - GREATER THAN OR EQUAL DATE %s", phrase)
+	minTime, err := queryTimeFromString(phrase)
+	if err != nil {
+		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
+	}
+	q := NewDateRangeInclusiveQuery(minTime, time.Time{}, &minInclusive, nil)
+	q.SetField(field)
+	$$ = q
+}
+|
+tSTRING tCOLON tLESS tPHRASE {
+	field := $1
+	maxInclusive := false
+	phrase := $4
+
+	logDebugGrammar("FIELD - LESS THAN DATE %s", phrase)
+	maxTime, err := queryTimeFromString(phrase)
+	if err != nil {
+		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
+	}
+	q := NewDateRangeInclusiveQuery(time.Time{}, maxTime, nil, &maxInclusive)
+	q.SetField(field)
+	$$ = q
+}
+|
+tSTRING tCOLON tLESS tEQUAL tPHRASE {
+	field := $1
+	maxInclusive := true
+	phrase := $5
+
+	logDebugGrammar("FIELD - LESS THAN OR EQUAL DATE %s", phrase)
+	maxTime, err := queryTimeFromString(phrase)
+	if err != nil {
+		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
+	}
+	q := NewDateRangeInclusiveQuery(time.Time{}, maxTime, nil, &maxInclusive)
+	q.SetField(field)
+	$$ = q
+};
+
+searchSuffix:
+/* empty */ {
+	$$ = nil
+}
+|
+tBOOST {
+  $$ = nil
+	boost, err := strconv.ParseFloat($1, 64)
+	if err != nil {
+	  yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid boost value: %v", err))
+	} else {
+		$$ = &boost
+	}
+	logDebugGrammar("BOOST %f", boost)
+};
+
+posOrNegNumber:
+tNUMBER {
+	$$ = $1
+}
+|
+tMINUS tNUMBER {
+	$$ = "-" + $2
+};

vendor/github.com/blevesearch/bleve/search/query/query_string.y.go

@@ -0,0 +1,815 @@
+package query
+
+import __yyfmt__ "fmt"
+
+//line query_string.y:2
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func logDebugGrammar(format string, v ...interface{}) {
+	if debugParser {
+		logger.Printf(format, v...)
+	}
+}
+
+//line query_string.y:17
+type yySymType struct {
+	yys int
+	s   string
+	n   int
+	f   float64
+	q   Query
+	pf  *float64
+}
+
+const tSTRING = 57346
+const tPHRASE = 57347
+const tPLUS = 57348
+const tMINUS = 57349
+const tCOLON = 57350
+const tBOOST = 57351
+const tNUMBER = 57352
+const tGREATER = 57353
+const tLESS = 57354
+const tEQUAL = 57355
+const tTILDE = 57356
+
+var yyToknames = [...]string{
+	"$end",
+	"error",
+	"$unk",
+	"tSTRING",
+	"tPHRASE",
+	"tPLUS",
+	"tMINUS",
+	"tCOLON",
+	"tBOOST",
+	"tNUMBER",
+	"tGREATER",
+	"tLESS",
+	"tEQUAL",
+	"tTILDE",
+}
+var yyStatenames = [...]string{}
+
+const yyEofCode = 1
+const yyErrCode = 2
+const yyInitialStackSize = 16
+
+//line yacctab:1
+var yyExca = [...]int{
+	-1, 1,
+	1, -1,
+	-2, 0,
+	-1, 3,
+	1, 3,
+	-2, 5,
+}
+
+const yyNprod = 28
+const yyPrivate = 57344
+
+var yyTokenNames []string
+var yyStates []string
+
+const yyLast = 42
+
+var yyAct = [...]int{
+
+	17, 16, 18, 23, 22, 30, 3, 21, 19, 20,
+	29, 26, 22, 22, 1, 21, 21, 15, 28, 25,
+	24, 27, 34, 14, 22, 13, 31, 21, 32, 33,
+	22, 9, 11, 21, 5, 6, 2, 10, 4, 12,
+	7, 8,
+}
+var yyPact = [...]int{
+
+	28, -1000, -1000, 28, 27, -1000, -1000, -1000, 16, 9,
+	-1000, -1000, -1000, -1000, -1000, -3, -11, -1000, -1000, 6,
+	5, -1000, -5, -1000, -1000, 23, -1000, -1000, 17, -1000,
+	-1000, -1000, -1000, -1000, -1000,
+}
+var yyPgo = [...]int{
+
+	0, 0, 41, 39, 38, 14, 36, 6,
+}
+var yyR1 = [...]int{
+
+	0, 5, 6, 6, 7, 4, 4, 4, 2, 2,
+	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+	2, 2, 2, 2, 3, 3, 1, 1,
+}
+var yyR2 = [...]int{
+
+	0, 1, 2, 1, 3, 0, 1, 1, 1, 2,
+	4, 1, 1, 3, 3, 3, 4, 5, 4, 5,
+	4, 5, 4, 5, 0, 1, 1, 2,
+}
+var yyChk = [...]int{
+
+	-1000, -5, -6, -7, -4, 6, 7, -6, -2, 4,
+	10, 5, -3, 9, 14, 8, 4, -1, 5, 11,
+	12, 10, 7, 14, -1, 13, 5, -1, 13, 5,
+	10, -1, 5, -1, 5,
+}
+var yyDef = [...]int{
+
+	5, -2, 1, -2, 0, 6, 7, 2, 24, 8,
+	11, 12, 4, 25, 9, 0, 13, 14, 15, 0,
+	0, 26, 0, 10, 16, 0, 20, 18, 0, 22,
+	27, 17, 21, 19, 23,
+}
+var yyTok1 = [...]int{
+
+	1,
+}
+var yyTok2 = [...]int{
+
+	2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+	12, 13, 14,
+}
+var yyTok3 = [...]int{
+	0,
+}
+
+var yyErrorMessages = [...]struct {
+	state int
+	token int
+	msg   string
+}{}
+
+//line yaccpar:1
+
+/*	parser for yacc output	*/
+
+var (
+	yyDebug        = 0
+	yyErrorVerbose = false
+)
+
+type yyLexer interface {
+	Lex(lval *yySymType) int
+	Error(s string)
+}
+
+type yyParser interface {
+	Parse(yyLexer) int
+	Lookahead() int
+}
+
+type yyParserImpl struct {
+	lval  yySymType
+	stack [yyInitialStackSize]yySymType
+	char  int
+}
+
+func (p *yyParserImpl) Lookahead() int {
+	return p.char
+}
+
+func yyNewParser() yyParser {
+	return &yyParserImpl{}
+}
+
+const yyFlag = -1000
+
+func yyTokname(c int) string {
+	if c >= 1 && c-1 < len(yyToknames) {
+		if yyToknames[c-1] != "" {
+			return yyToknames[c-1]
+		}
+	}
+	return __yyfmt__.Sprintf("tok-%v", c)
+}
+
+func yyStatname(s int) string {
+	if s >= 0 && s < len(yyStatenames) {
+		if yyStatenames[s] != "" {
+			return yyStatenames[s]
+		}
+	}
+	return __yyfmt__.Sprintf("state-%v", s)
+}
+
+func yyErrorMessage(state, lookAhead int) string {
+	const TOKSTART = 4
+
+	if !yyErrorVerbose {
+		return "syntax error"
+	}
+
+	for _, e := range yyErrorMessages {
+		if e.state == state && e.token == lookAhead {
+			return "syntax error: " + e.msg
+		}
+	}
+
+	res := "syntax error: unexpected " + yyTokname(lookAhead)
+
+	// To match Bison, suggest at most four expected tokens.
+	expected := make([]int, 0, 4)
+
+	// Look for shiftable tokens.
+	base := yyPact[state]
+	for tok := TOKSTART; tok-1 < len(yyToknames); tok++ {
+		if n := base + tok; n >= 0 && n < yyLast && yyChk[yyAct[n]] == tok {
+			if len(expected) == cap(expected) {
+				return res
+			}
+			expected = append(expected, tok)
+		}
+	}
+
+	if yyDef[state] == -2 {
+		i := 0
+		for yyExca[i] != -1 || yyExca[i+1] != state {
+			i += 2
+		}
+
+		// Look for tokens that we accept or reduce.
+		for i += 2; yyExca[i] >= 0; i += 2 {
+			tok := yyExca[i]
+			if tok < TOKSTART || yyExca[i+1] == 0 {
+				continue
+			}
+			if len(expected) == cap(expected) {
+				return res
+			}
+			expected = append(expected, tok)
+		}
+
+		// If the default action is to accept or reduce, give up.
+		if yyExca[i+1] != 0 {
+			return res
+		}
+	}
+
+	for i, tok := range expected {
+		if i == 0 {
+			res += ", expecting "
+		} else {
+			res += " or "
+		}
+		res += yyTokname(tok)
+	}
+	return res
+}
+
+func yylex1(lex yyLexer, lval *yySymType) (char, token int) {
+	token = 0
+	char = lex.Lex(lval)
+	if char <= 0 {
+		token = yyTok1[0]
+		goto out
+	}
+	if char < len(yyTok1) {
+		token = yyTok1[char]
+		goto out
+	}
+	if char >= yyPrivate {
+		if char < yyPrivate+len(yyTok2) {
+			token = yyTok2[char-yyPrivate]
+			goto out
+		}
+	}
+	for i := 0; i < len(yyTok3); i += 2 {
+		token = yyTok3[i+0]
+		if token == char {
+			token = yyTok3[i+1]
+			goto out
+		}
+	}
+
+out:
+	if token == 0 {
+		token = yyTok2[1] /* unknown char */
+	}
+	if yyDebug >= 3 {
+		__yyfmt__.Printf("lex %s(%d)\n", yyTokname(token), uint(char))
+	}
+	return char, token
+}
+
+func yyParse(yylex yyLexer) int {
+	return yyNewParser().Parse(yylex)
+}
+
+func (yyrcvr *yyParserImpl) Parse(yylex yyLexer) int {
+	var yyn int
+	var yyVAL yySymType
+	var yyDollar []yySymType
+	_ = yyDollar // silence set and not used
+	yyS := yyrcvr.stack[:]
+
+	Nerrs := 0   /* number of errors */
+	Errflag := 0 /* error recovery flag */
+	yystate := 0
+	yyrcvr.char = -1
+	yytoken := -1 // yyrcvr.char translated into internal numbering
+	defer func() {
+		// Make sure we report no lookahead when not parsing.
+		yystate = -1
+		yyrcvr.char = -1
+		yytoken = -1
+	}()
+	yyp := -1
+	goto yystack
+
+ret0:
+	return 0
+
+ret1:
+	return 1
+
+yystack:
+	/* put a state and value onto the stack */
+	if yyDebug >= 4 {
+		__yyfmt__.Printf("char %v in %v\n", yyTokname(yytoken), yyStatname(yystate))
+	}
+
+	yyp++
+	if yyp >= len(yyS) {
+		nyys := make([]yySymType, len(yyS)*2)
+		copy(nyys, yyS)
+		yyS = nyys
+	}
+	yyS[yyp] = yyVAL
+	yyS[yyp].yys = yystate
+
+yynewstate:
+	yyn = yyPact[yystate]
+	if yyn <= yyFlag {
+		goto yydefault /* simple state */
+	}
+	if yyrcvr.char < 0 {
+		yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval)
+	}
+	yyn += yytoken
+	if yyn < 0 || yyn >= yyLast {
+		goto yydefault
+	}
+	yyn = yyAct[yyn]
+	if yyChk[yyn] == yytoken { /* valid shift */
+		yyrcvr.char = -1
+		yytoken = -1
+		yyVAL = yyrcvr.lval
+		yystate = yyn
+		if Errflag > 0 {
+			Errflag--
+		}
+		goto yystack
+	}
+
+yydefault:
+	/* default state action */
+	yyn = yyDef[yystate]
+	if yyn == -2 {
+		if yyrcvr.char < 0 {
+			yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval)
+		}
+
+		/* look through exception table */
+		xi := 0
+		for {
+			if yyExca[xi+0] == -1 && yyExca[xi+1] == yystate {
+				break
+			}
+			xi += 2
+		}
+		for xi += 2; ; xi += 2 {
+			yyn = yyExca[xi+0]
+			if yyn < 0 || yyn == yytoken {
+				break
+			}
+		}
+		yyn = yyExca[xi+1]
+		if yyn < 0 {
+			goto ret0
+		}
+	}
+	if yyn == 0 {
+		/* error ... attempt to resume parsing */
+		switch Errflag {
+		case 0: /* brand new error */
+			yylex.Error(yyErrorMessage(yystate, yytoken))
+			Nerrs++
+			if yyDebug >= 1 {
+				__yyfmt__.Printf("%s", yyStatname(yystate))
+				__yyfmt__.Printf(" saw %s\n", yyTokname(yytoken))
+			}
+			fallthrough
+
+		case 1, 2: /* incompletely recovered error ... try again */
+			Errflag = 3
+
+			/* find a state where "error" is a legal shift action */
+			for yyp >= 0 {
+				yyn = yyPact[yyS[yyp].yys] + yyErrCode
+				if yyn >= 0 && yyn < yyLast {
+					yystate = yyAct[yyn] /* simulate a shift of "error" */
+					if yyChk[yystate] == yyErrCode {
+						goto yystack
+					}
+				}
+
+				/* the current p has no shift on "error", pop stack */
+				if yyDebug >= 2 {
+					__yyfmt__.Printf("error recovery pops state %d\n", yyS[yyp].yys)
+				}
+				yyp--
+			}
+			/* there is no state on the stack with an error shift ... abort */
+			goto ret1
+
+		case 3: /* no shift yet; clobber input char */
+			if yyDebug >= 2 {
+				__yyfmt__.Printf("error recovery discards %s\n", yyTokname(yytoken))
+			}
+			if yytoken == yyEofCode {
+				goto ret1
+			}
+			yyrcvr.char = -1
+			yytoken = -1
+			goto yynewstate /* try again in the same state */
+		}
+	}
+
+	/* reduction by production yyn */
+	if yyDebug >= 2 {
+		__yyfmt__.Printf("reduce %v in:\n\t%v\n", yyn, yyStatname(yystate))
+	}
+
+	yynt := yyn
+	yypt := yyp
+	_ = yypt // guard against "declared and not used"
+
+	yyp -= yyR2[yyn]
+	// yyp is now the index of $0. Perform the default action. Iff the
+	// reduced production is ε, $1 is possibly out of range.
+	if yyp+1 >= len(yyS) {
+		nyys := make([]yySymType, len(yyS)*2)
+		copy(nyys, yyS)
+		yyS = nyys
+	}
+	yyVAL = yyS[yyp+1]
+
+	/* consult goto table to find next state */
+	yyn = yyR1[yyn]
+	yyg := yyPgo[yyn]
+	yyj := yyg + yyS[yyp].yys + 1
+
+	if yyj >= yyLast {
+		yystate = yyAct[yyg]
+	} else {
+		yystate = yyAct[yyj]
+		if yyChk[yystate] != -yyn {
+			yystate = yyAct[yyg]
+		}
+	}
+	// dummy call; replaced with literal code
+	switch yynt {
+
+	case 1:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line query_string.y:40
+		{
+			logDebugGrammar("INPUT")
+		}
+	case 2:
+		yyDollar = yyS[yypt-2 : yypt+1]
+		//line query_string.y:45
+		{
+			logDebugGrammar("SEARCH PARTS")
+		}
+	case 3:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line query_string.y:49
+		{
+			logDebugGrammar("SEARCH PART")
+		}
+	case 4:
+		yyDollar = yyS[yypt-3 : yypt+1]
+		//line query_string.y:54
+		{
+			query := yyDollar[2].q
+			if yyDollar[3].pf != nil {
+				if query, ok := query.(BoostableQuery); ok {
+					query.SetBoost(*yyDollar[3].pf)
+				}
+			}
+			switch yyDollar[1].n {
+			case queryShould:
+				yylex.(*lexerWrapper).query.AddShould(query)
+			case queryMust:
+				yylex.(*lexerWrapper).query.AddMust(query)
+			case queryMustNot:
+				yylex.(*lexerWrapper).query.AddMustNot(query)
+			}
+		}
+	case 5:
+		yyDollar = yyS[yypt-0 : yypt+1]
+		//line query_string.y:73
+		{
+			yyVAL.n = queryShould
+		}
+	case 6:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line query_string.y:77
+		{
+			logDebugGrammar("PLUS")
+			yyVAL.n = queryMust
+		}
+	case 7:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line query_string.y:82
+		{
+			logDebugGrammar("MINUS")
+			yyVAL.n = queryMustNot
+		}
+	case 8:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line query_string.y:88
+		{
+			str := yyDollar[1].s
+			logDebugGrammar("STRING - %s", str)
+			var q FieldableQuery
+			if strings.HasPrefix(str, "/") && strings.HasSuffix(str, "/") {
+				q = NewRegexpQuery(str[1 : len(str)-1])
+			} else if strings.ContainsAny(str, "*?") {
+				q = NewWildcardQuery(str)
+			} else {
+				q = NewMatchQuery(str)
+			}
+			yyVAL.q = q
+		}
+	case 9:
+		yyDollar = yyS[yypt-2 : yypt+1]
+		//line query_string.y:102
+		{
+			str := yyDollar[1].s
+			fuzziness, err := strconv.ParseFloat(yyDollar[2].s, 64)
+			if err != nil {
+				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid fuzziness value: %v", err))
+			}
+			logDebugGrammar("FUZZY STRING - %s %f", str, fuzziness)
+			q := NewMatchQuery(str)
+			q.SetFuzziness(int(fuzziness))
+			yyVAL.q = q
+		}
+	case 10:
+		yyDollar = yyS[yypt-4 : yypt+1]
+		//line query_string.y:114
+		{
+			field := yyDollar[1].s
+			str := yyDollar[3].s
+			fuzziness, err := strconv.ParseFloat(yyDollar[4].s, 64)
+			if err != nil {
+				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid fuzziness value: %v", err))
+			}
+			logDebugGrammar("FIELD - %s FUZZY STRING - %s %f", field, str, fuzziness)
+			q := NewMatchQuery(str)
+			q.SetFuzziness(int(fuzziness))
+			q.SetField(field)
+			yyVAL.q = q
+		}
+	case 11:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line query_string.y:128
+		{
+			str := yyDollar[1].s
+			logDebugGrammar("STRING - %s", str)
+			q1 := NewMatchQuery(str)
+			val, err := strconv.ParseFloat(yyDollar[1].s, 64)
+			if err != nil {
+				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
+			}
+			inclusive := true
+			q2 := NewNumericRangeInclusiveQuery(&val, &val, &inclusive, &inclusive)
+			q := NewDisjunctionQuery([]Query{q1, q2})
+			q.queryStringMode = true
+			yyVAL.q = q
+		}
+	case 12:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line query_string.y:143
+		{
+			phrase := yyDollar[1].s
+			logDebugGrammar("PHRASE - %s", phrase)
+			q := NewMatchPhraseQuery(phrase)
+			yyVAL.q = q
+		}
+	case 13:
+		yyDollar = yyS[yypt-3 : yypt+1]
+		//line query_string.y:150
+		{
+			field := yyDollar[1].s
+			str := yyDollar[3].s
+			logDebugGrammar("FIELD - %s STRING - %s", field, str)
+			var q FieldableQuery
+			if strings.HasPrefix(str, "/") && strings.HasSuffix(str, "/") {
+				q = NewRegexpQuery(str[1 : len(str)-1])
+			} else if strings.ContainsAny(str, "*?") {
+				q = NewWildcardQuery(str)
+			} else {
+				q = NewMatchQuery(str)
+			}
+			q.SetField(field)
+			yyVAL.q = q
+		}
+	case 14:
+		yyDollar = yyS[yypt-3 : yypt+1]
+		//line query_string.y:166
+		{
+			field := yyDollar[1].s
+			str := yyDollar[3].s
+			logDebugGrammar("FIELD - %s STRING - %s", field, str)
+			q1 := NewMatchQuery(str)
+			q1.SetField(field)
+			val, err := strconv.ParseFloat(yyDollar[3].s, 64)
+			if err != nil {
+				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
+			}
+			inclusive := true
+			q2 := NewNumericRangeInclusiveQuery(&val, &val, &inclusive, &inclusive)
+			q2.SetField(field)
+			q := NewDisjunctionQuery([]Query{q1, q2})
+			q.queryStringMode = true
+			yyVAL.q = q
+		}
+	case 15:
+		yyDollar = yyS[yypt-3 : yypt+1]
+		//line query_string.y:184
+		{
+			field := yyDollar[1].s
+			phrase := yyDollar[3].s
+			logDebugGrammar("FIELD - %s PHRASE - %s", field, phrase)
+			q := NewMatchPhraseQuery(phrase)
+			q.SetField(field)
+			yyVAL.q = q
+		}
+	case 16:
+		yyDollar = yyS[yypt-4 : yypt+1]
+		//line query_string.y:193
+		{
+			field := yyDollar[1].s
+			min, err := strconv.ParseFloat(yyDollar[4].s, 64)
+			if err != nil {
+				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
+			}
+			minInclusive := false
+			logDebugGrammar("FIELD - GREATER THAN %f", min)
+			q := NewNumericRangeInclusiveQuery(&min, nil, &minInclusive, nil)
+			q.SetField(field)
+			yyVAL.q = q
+		}
+	case 17:
+		yyDollar = yyS[yypt-5 : yypt+1]
+		//line query_string.y:206
+		{
+			field := yyDollar[1].s
+			min, err := strconv.ParseFloat(yyDollar[5].s, 64)
+			if err != nil {
+				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
+			}
+			minInclusive := true
+			logDebugGrammar("FIELD - GREATER THAN OR EQUAL %f", min)
+			q := NewNumericRangeInclusiveQuery(&min, nil, &minInclusive, nil)
+			q.SetField(field)
+			yyVAL.q = q
+		}
+	case 18:
+		yyDollar = yyS[yypt-4 : yypt+1]
+		//line query_string.y:219
+		{
+			field := yyDollar[1].s
+			max, err := strconv.ParseFloat(yyDollar[4].s, 64)
+			if err != nil {
+				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
+			}
+			maxInclusive := false
+			logDebugGrammar("FIELD - LESS THAN %f", max)
+			q := NewNumericRangeInclusiveQuery(nil, &max, nil, &maxInclusive)
+			q.SetField(field)
+			yyVAL.q = q
+		}
+	case 19:
+		yyDollar = yyS[yypt-5 : yypt+1]
+		//line query_string.y:232
+		{
+			field := yyDollar[1].s
+			max, err := strconv.ParseFloat(yyDollar[5].s, 64)
+			if err != nil {
+				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
+			}
+			maxInclusive := true
+			logDebugGrammar("FIELD - LESS THAN OR EQUAL %f", max)
+			q := NewNumericRangeInclusiveQuery(nil, &max, nil, &maxInclusive)
+			q.SetField(field)
+			yyVAL.q = q
+		}
+	case 20:
+		yyDollar = yyS[yypt-4 : yypt+1]
+		//line query_string.y:245
+		{
+			field := yyDollar[1].s
+			minInclusive := false
+			phrase := yyDollar[4].s
+
+			logDebugGrammar("FIELD - GREATER THAN DATE %s", phrase)
+			minTime, err := queryTimeFromString(phrase)
+			if err != nil {
+				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
+			}
+			q := NewDateRangeInclusiveQuery(minTime, time.Time{}, &minInclusive, nil)
+			q.SetField(field)
+			yyVAL.q = q
+		}
+	case 21:
+		yyDollar = yyS[yypt-5 : yypt+1]
+		//line query_string.y:260
+		{
+			field := yyDollar[1].s
+			minInclusive := true
+			phrase := yyDollar[5].s
+
+			logDebugGrammar("FIELD - GREATER THAN OR EQUAL DATE %s", phrase)
+			minTime, err := queryTimeFromString(phrase)
+			if err != nil {
+				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
+			}
+			q := NewDateRangeInclusiveQuery(minTime, time.Time{}, &minInclusive, nil)
+			q.SetField(field)
+			yyVAL.q = q
+		}
+	case 22:
+		yyDollar = yyS[yypt-4 : yypt+1]
+		//line query_string.y:275
+		{
+			field := yyDollar[1].s
+			maxInclusive := false
+			phrase := yyDollar[4].s
+
+			logDebugGrammar("FIELD - LESS THAN DATE %s", phrase)
+			maxTime, err := queryTimeFromString(phrase)
+			if err != nil {
+				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
+			}
+			q := NewDateRangeInclusiveQuery(time.Time{}, maxTime, nil, &maxInclusive)
+			q.SetField(field)
+			yyVAL.q = q
+		}
+	case 23:
+		yyDollar = yyS[yypt-5 : yypt+1]
+		//line query_string.y:290
+		{
+			field := yyDollar[1].s
+			maxInclusive := true
+			phrase := yyDollar[5].s
+
+			logDebugGrammar("FIELD - LESS THAN OR EQUAL DATE %s", phrase)
+			maxTime, err := queryTimeFromString(phrase)
+			if err != nil {
+				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
+			}
+			q := NewDateRangeInclusiveQuery(time.Time{}, maxTime, nil, &maxInclusive)
+			q.SetField(field)
+			yyVAL.q = q
+		}
+	case 24:
+		yyDollar = yyS[yypt-0 : yypt+1]
+		//line query_string.y:306
+		{
+			yyVAL.pf = nil
+		}
+	case 25:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line query_string.y:310
+		{
+			yyVAL.pf = nil
+			boost, err := strconv.ParseFloat(yyDollar[1].s, 64)
+			if err != nil {
+				yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid boost value: %v", err))
+			} else {
+				yyVAL.pf = &boost
+			}
+			logDebugGrammar("BOOST %f", boost)
+		}
+	case 26:
+		yyDollar = yyS[yypt-1 : yypt+1]
+		//line query_string.y:322
+		{
+			yyVAL.s = yyDollar[1].s
+		}
+	case 27:
+		yyDollar = yyS[yypt-2 : yypt+1]
+		//line query_string.y:326
+		{
+			yyVAL.s = "-" + yyDollar[2].s
+		}
+	}
+	goto yystack /* stack new state and value */
+}

vendor/github.com/blevesearch/bleve/search/query/query_string_lex.go

@@ -0,0 +1,322 @@
+//  Copyright (c) 2016 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"bufio"
+	"io"
+	"strings"
+	"unicode"
+)
+
+const reservedChars = "+-=&|><!(){}[]^\"~*?:\\/ "
+
+func unescape(escaped string) string {
+	// see if this character can be escaped
+	if strings.ContainsAny(escaped, reservedChars) {
+		return escaped
+	}
+	// otherwise return it with the \ intact
+	return "\\" + escaped
+}
+
+type queryStringLex struct {
+	in            *bufio.Reader
+	buf           string
+	currState     lexState
+	currConsumed  bool
+	inEscape      bool
+	nextToken     *yySymType
+	nextTokenType int
+	seenDot       bool
+	nextRune      rune
+	nextRuneSize  int
+	atEOF         bool
+}
+
+func (l *queryStringLex) reset() {
+	l.buf = ""
+	l.inEscape = false
+	l.seenDot = false
+}
+
+func (l *queryStringLex) Error(msg string) {
+	panic(msg)
+}
+
+func (l *queryStringLex) Lex(lval *yySymType) int {
+	var err error
+
+	for l.nextToken == nil {
+		if l.currConsumed {
+			l.nextRune, l.nextRuneSize, err = l.in.ReadRune()
+			if err != nil && err == io.EOF {
+				l.nextRune = 0
+				l.atEOF = true
+			} else if err != nil {
+				return 0
+			}
+		}
+		l.currState, l.currConsumed = l.currState(l, l.nextRune, l.atEOF)
+		if l.currState == nil {
+			return 0
+		}
+	}
+
+	*lval = *l.nextToken
+	rv := l.nextTokenType
+	l.nextToken = nil
+	l.nextTokenType = 0
+	return rv
+}
+
+func newQueryStringLex(in io.Reader) *queryStringLex {
+	return &queryStringLex{
+		in:           bufio.NewReader(in),
+		currState:    startState,
+		currConsumed: true,
+	}
+}
+
+type lexState func(l *queryStringLex, next rune, eof bool) (lexState, bool)
+
+func startState(l *queryStringLex, next rune, eof bool) (lexState, bool) {
+	if eof {
+		return nil, false
+	}
+
+	// handle inside escape case up front
+	if l.inEscape {
+		l.inEscape = false
+		l.buf += unescape(string(next))
+		return inStrState, true
+	}
+
+	switch next {
+	case '"':
+		return inPhraseState, true
+	case '+', '-', ':', '>', '<', '=':
+		l.buf += string(next)
+		return singleCharOpState, true
+	case '^':
+		return inBoostState, true
+	case '~':
+		return inTildeState, true
+	}
+
+	switch {
+	case !l.inEscape && next == '\\':
+		l.inEscape = true
+		return startState, true
+	case unicode.IsDigit(next):
+		l.buf += string(next)
+		return inNumOrStrState, true
+	case !unicode.IsSpace(next):
+		l.buf += string(next)
+		return inStrState, true
+	}
+
+	// doesn't look like anything, just eat it and stay here
+	l.reset()
+	return startState, true
+}
+
+func inPhraseState(l *queryStringLex, next rune, eof bool) (lexState, bool) {
+	// unterminated phrase eats the phrase
+	if eof {
+		l.Error("unterminated quote")
+		return nil, false
+	}
+
+	// only a non-escaped " ends the phrase
+	if !l.inEscape && next == '"' {
+		// end phrase
+		l.nextTokenType = tPHRASE
+		l.nextToken = &yySymType{
+			s: l.buf,
+		}
+		logDebugTokens("PHRASE - '%s'", l.nextToken.s)
+		l.reset()
+		return startState, true
+	} else if !l.inEscape && next == '\\' {
+		l.inEscape = true
+	} else if l.inEscape {
+		// if in escape, end it
+		l.inEscape = false
+		l.buf += unescape(string(next))
+	} else {
+		l.buf += string(next)
+	}
+
+	return inPhraseState, true
+}
+
+func singleCharOpState(l *queryStringLex, next rune, eof bool) (lexState, bool) {
+	l.nextToken = &yySymType{}
+
+	switch l.buf {
+	case "+":
+		l.nextTokenType = tPLUS
+		logDebugTokens("PLUS")
+	case "-":
+		l.nextTokenType = tMINUS
+		logDebugTokens("MINUS")
+	case ":":
+		l.nextTokenType = tCOLON
+		logDebugTokens("COLON")
+	case ">":
+		l.nextTokenType = tGREATER
+		logDebugTokens("GREATER")
+	case "<":
+		l.nextTokenType = tLESS
+		logDebugTokens("LESS")
+	case "=":
+		l.nextTokenType = tEQUAL
+		logDebugTokens("EQUAL")
+	}
+
+	l.reset()
+	return startState, false
+}
+
+func inBoostState(l *queryStringLex, next rune, eof bool) (lexState, bool) {
+
+	// only a non-escaped space ends the boost (or eof)
+	if eof || (!l.inEscape && next == ' ') {
+		// end boost
+		l.nextTokenType = tBOOST
+		if l.buf == "" {
+			l.buf = "1"
+		}
+		l.nextToken = &yySymType{
+			s: l.buf,
+		}
+		logDebugTokens("BOOST - '%s'", l.nextToken.s)
+		l.reset()
+		return startState, true
+	} else if !l.inEscape && next == '\\' {
+		l.inEscape = true
+	} else if l.inEscape {
+		// if in escape, end it
+		l.inEscape = false
+		l.buf += unescape(string(next))
+	} else {
+		l.buf += string(next)
+	}
+
+	return inBoostState, true
+}
+
+func inTildeState(l *queryStringLex, next rune, eof bool) (lexState, bool) {
+
+	// only a non-escaped space ends the tilde (or eof)
+	if eof || (!l.inEscape && next == ' ') {
+		// end tilde
+		l.nextTokenType = tTILDE
+		if l.buf == "" {
+			l.buf = "1"
+		}
+		l.nextToken = &yySymType{
+			s: l.buf,
+		}
+		logDebugTokens("TILDE - '%s'", l.nextToken.s)
+		l.reset()
+		return startState, true
+	} else if !l.inEscape && next == '\\' {
+		l.inEscape = true
+	} else if l.inEscape {
+		// if in escape, end it
+		l.inEscape = false
+		l.buf += unescape(string(next))
+	} else {
+		l.buf += string(next)
+	}
+
+	return inTildeState, true
+}
+
+func inNumOrStrState(l *queryStringLex, next rune, eof bool) (lexState, bool) {
+	// only a non-escaped space ends the tilde (or eof)
+	if eof || (!l.inEscape && next == ' ') {
+		// end number
+		l.nextTokenType = tNUMBER
+		l.nextToken = &yySymType{
+			s: l.buf,
+		}
+		logDebugTokens("NUMBER - '%s'", l.nextToken.s)
+		l.reset()
+		return startState, true
+	} else if !l.inEscape && next == '\\' {
+		l.inEscape = true
+		return inNumOrStrState, true
+	} else if l.inEscape {
+		// if in escape, end it
+		l.inEscape = false
+		l.buf += unescape(string(next))
+		// go directly to string, no successfully or unsuccessfully
+		// escaped string results in a valid number
+		return inStrState, true
+	}
+
+	// see where to go
+	if !l.seenDot && next == '.' {
+		// stay in this state
+		l.buf += string(next)
+		return inNumOrStrState, true
+	} else if unicode.IsDigit(next) {
+		l.buf += string(next)
+		return inNumOrStrState, true
+	}
+
+	// doesn't look like an number, transition
+	l.buf += string(next)
+	return inStrState, true
+}
+
+func inStrState(l *queryStringLex, next rune, eof bool) (lexState, bool) {
+	// end on non-escped space, colon, tilde, boost (or eof)
+	if eof || (!l.inEscape && (next == ' ' || next == ':' || next == '^' || next == '~')) {
+		// end string
+		l.nextTokenType = tSTRING
+		l.nextToken = &yySymType{
+			s: l.buf,
+		}
+		logDebugTokens("STRING - '%s'", l.nextToken.s)
+		l.reset()
+
+		consumed := true
+		if !eof && (next == ':' || next == '^' || next == '~') {
+			consumed = false
+		}
+
+		return startState, consumed
+	} else if !l.inEscape && next == '\\' {
+		l.inEscape = true
+	} else if l.inEscape {
+		// if in escape, end it
+		l.inEscape = false
+		l.buf += unescape(string(next))
+	} else {
+		l.buf += string(next)
+	}
+
+	return inStrState, true
+}
+
+func logDebugTokens(format string, v ...interface{}) {
+	if debugLexer {
+		logger.Printf(format, v...)
+	}
+}

vendor/github.com/blevesearch/bleve/search/query/query_string_parser.go

@@ -0,0 +1,85 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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.
+
+// as of Go 1.8 this requires the goyacc external tool
+// available from golang.org/x/tools/cmd/goyacc
+
+//go:generate goyacc -o query_string.y.go query_string.y
+//go:generate sed -i.tmp -e 1d query_string.y.go
+//go:generate rm query_string.y.go.tmp
+
+// note: OSX sed and gnu sed handle the -i (in-place) option differently.
+// using -i.tmp works on both, at the expense of having to remove
+// the unsightly .tmp files
+
+package query
+
+import (
+	"fmt"
+	"strings"
+)
+
+var debugParser bool
+var debugLexer bool
+
+func parseQuerySyntax(query string) (rq Query, err error) {
+	if query == "" {
+		return NewMatchNoneQuery(), nil
+	}
+	lex := newLexerWrapper(newQueryStringLex(strings.NewReader(query)))
+	doParse(lex)
+
+	if len(lex.errs) > 0 {
+		return nil, fmt.Errorf(strings.Join(lex.errs, "\n"))
+	}
+	return lex.query, nil
+}
+
+func doParse(lex *lexerWrapper) {
+	defer func() {
+		r := recover()
+		if r != nil {
+			lex.errs = append(lex.errs, fmt.Sprintf("parse error: %v", r))
+		}
+	}()
+
+	yyParse(lex)
+}
+
+const (
+	queryShould = iota
+	queryMust
+	queryMustNot
+)
+
+type lexerWrapper struct {
+	lex   yyLexer
+	errs  []string
+	query *BooleanQuery
+}
+
+func newLexerWrapper(lex yyLexer) *lexerWrapper {
+	return &lexerWrapper{
+		lex:   lex,
+		query: NewBooleanQueryForQueryString(nil, nil, nil),
+	}
+}
+
+func (l *lexerWrapper) Lex(lval *yySymType) int {
+	return l.lex.Lex(lval)
+}
+
+func (l *lexerWrapper) Error(s string) {
+	l.errs = append(l.errs, s)
+}

vendor/github.com/blevesearch/bleve/search/query/regexp.go

@@ -0,0 +1,96 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+type RegexpQuery struct {
+	Regexp   string `json:"regexp"`
+	FieldVal string `json:"field,omitempty"`
+	BoostVal *Boost `json:"boost,omitempty"`
+	compiled *regexp.Regexp
+}
+
+// NewRegexpQuery creates a new Query which finds
+// documents containing terms that match the
+// specified regular expression.  The regexp pattern
+// SHOULD NOT include ^ or $ modifiers, the search
+// will only match entire terms even without them.
+func NewRegexpQuery(regexp string) *RegexpQuery {
+	return &RegexpQuery{
+		Regexp: regexp,
+	}
+}
+
+func (q *RegexpQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *RegexpQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *RegexpQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *RegexpQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *RegexpQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+	err := q.compile()
+	if err != nil {
+		return nil, err
+	}
+
+	return searcher.NewRegexpSearcher(i, q.compiled, field, q.BoostVal.Value(), options)
+}
+
+func (q *RegexpQuery) Validate() error {
+	return q.compile()
+}
+
+func (q *RegexpQuery) compile() error {
+	if q.compiled == nil {
+		// require that pattern NOT be anchored to start and end of term
+		actualRegexp := q.Regexp
+		if strings.HasPrefix(actualRegexp, "^") {
+			actualRegexp = actualRegexp[1:] // remove leading ^
+		}
+		// do not attempt to remove trailing $, it's presence is not
+		// known to interfere with LiteralPrefix() the way ^ does
+		// and removing $ introduces possible ambiguities with escaped \$, \\$, etc
+		var err error
+		q.compiled, err = regexp.Compile(actualRegexp)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

vendor/github.com/blevesearch/bleve/search/query/term.go

@@ -0,0 +1,61 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+type TermQuery struct {
+	Term     string `json:"term"`
+	FieldVal string `json:"field,omitempty"`
+	BoostVal *Boost `json:"boost,omitempty"`
+}
+
+// NewTermQuery creates a new Query for finding an
+// exact term match in the index.
+func NewTermQuery(term string) *TermQuery {
+	return &TermQuery{
+		Term: term,
+	}
+}
+
+func (q *TermQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *TermQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *TermQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *TermQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *TermQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+	return searcher.NewTermSearcher(i, q.Term, field, q.BoostVal.Value(), options)
+}

vendor/github.com/blevesearch/bleve/search/query/term_range.go

@@ -0,0 +1,95 @@
+//  Copyright (c) 2017 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"fmt"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+type TermRangeQuery struct {
+	Min          string `json:"min,omitempty"`
+	Max          string `json:"max,omitempty"`
+	InclusiveMin *bool  `json:"inclusive_min,omitempty"`
+	InclusiveMax *bool  `json:"inclusive_max,omitempty"`
+	FieldVal     string `json:"field,omitempty"`
+	BoostVal     *Boost `json:"boost,omitempty"`
+}
+
+// NewTermRangeQuery creates a new Query for ranges
+// of text term values.
+// Either, but not both endpoints can be nil.
+// The minimum value is inclusive.
+// The maximum value is exclusive.
+func NewTermRangeQuery(min, max string) *TermRangeQuery {
+	return NewTermRangeInclusiveQuery(min, max, nil, nil)
+}
+
+// NewTermRangeInclusiveQuery creates a new Query for ranges
+// of numeric values.
+// Either, but not both endpoints can be nil.
+// Control endpoint inclusion with inclusiveMin, inclusiveMax.
+func NewTermRangeInclusiveQuery(min, max string, minInclusive, maxInclusive *bool) *TermRangeQuery {
+	return &TermRangeQuery{
+		Min:          min,
+		Max:          max,
+		InclusiveMin: minInclusive,
+		InclusiveMax: maxInclusive,
+	}
+}
+
+func (q *TermRangeQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *TermRangeQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *TermRangeQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *TermRangeQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *TermRangeQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+	var minTerm []byte
+	if q.Min != "" {
+		minTerm = []byte(q.Min)
+	}
+	var maxTerm []byte
+	if q.Max != "" {
+		maxTerm = []byte(q.Max)
+	}
+	return searcher.NewTermRangeSearcher(i, minTerm, maxTerm, q.InclusiveMin, q.InclusiveMax, field, q.BoostVal.Value(), options)
+}
+
+func (q *TermRangeQuery) Validate() error {
+	if q.Min == "" && q.Min == q.Max {
+		return fmt.Errorf("term range query must specify min or max")
+	}
+	return nil
+}

vendor/github.com/blevesearch/bleve/search/query/wildcard.go

@@ -0,0 +1,106 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//
+// 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 query
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/mapping"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/searcher"
+)
+
+var wildcardRegexpReplacer = strings.NewReplacer(
+	// characters in the wildcard that must
+	// be escaped in the regexp
+	"+", `\+`,
+	"(", `\(`,
+	")", `\)`,
+	"^", `\^`,
+	"$", `\$`,
+	".", `\.`,
+	"{", `\{`,
+	"}", `\}`,
+	"[", `\[`,
+	"]", `\]`,
+	`|`, `\|`,
+	`\`, `\\`,
+	// wildcard characters
+	"*", ".*",
+	"?", ".")
+
+type WildcardQuery struct {
+	Wildcard string `json:"wildcard"`
+	FieldVal string `json:"field,omitempty"`
+	BoostVal *Boost `json:"boost,omitempty"`
+	compiled *regexp.Regexp
+}
+
+// NewWildcardQuery creates a new Query which finds
+// documents containing terms that match the
+// specified wildcard.  In the wildcard pattern '*'
+// will match any sequence of 0 or more characters,
+// and '?' will match any single character.
+func NewWildcardQuery(wildcard string) *WildcardQuery {
+	return &WildcardQuery{
+		Wildcard: wildcard,
+	}
+}
+
+func (q *WildcardQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *WildcardQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *WildcardQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *WildcardQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *WildcardQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+	if q.compiled == nil {
+		var err error
+		q.compiled, err = q.convertToRegexp()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return searcher.NewRegexpSearcher(i, q.compiled, field, q.BoostVal.Value(), options)
+}
+
+func (q *WildcardQuery) Validate() error {
+	var err error
+	q.compiled, err = q.convertToRegexp()
+	return err
+}
+
+func (q *WildcardQuery) convertToRegexp() (*regexp.Regexp, error) {
+	regexpString := wildcardRegexpReplacer.Replace(q.Wildcard)
+	return regexp.Compile(regexpString)
+}