Adding upstream version 2.5.1.

Signed-off-by: Daniel Baumann <daniel@debian.org>

search/query/bool_field.go

@@ -0,0 +1,66 @@
+//  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 (
+	"context"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+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(ctx context.Context, 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(ctx, i, term, field, q.BoostVal.Value(), options)
+}

search/query/boolean.go

@@ -0,0 +1,259 @@
+//  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 (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	"github.com/blevesearch/bleve/v2/util"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+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 m == nil {
+		return
+	}
+	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 m == nil {
+		return
+	}
+	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 m == nil {
+		return
+	}
+	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(ctx context.Context, 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(ctx, 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(ctx, 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(ctx, 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(ctx, 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(ctx, 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 := util.UnmarshalJSON(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
+}

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)
+}

search/query/conjunction.go

@@ -0,0 +1,112 @@
+//  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 (
+	"context"
+	"encoding/json"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	"github.com/blevesearch/bleve/v2/util"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+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) {
+	q.Conjuncts = append(q.Conjuncts, aq...)
+}
+
+func (q *ConjunctionQuery) Searcher(ctx context.Context, 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(ctx, 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(ctx, 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 := util.UnmarshalJSON(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
+}

search/query/date_range.go

@@ -0,0 +1,192 @@
+//  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 (
+	"context"
+	"fmt"
+	"math"
+	"time"
+
+	"github.com/blevesearch/bleve/v2/analysis/datetime/optional"
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/numeric"
+	"github.com/blevesearch/bleve/v2/registry"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	"github.com/blevesearch/bleve/v2/util"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+// 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
+}
+
+var MinRFC3339CompatibleTime time.Time
+var MaxRFC3339CompatibleTime time.Time
+
+func init() {
+	MinRFC3339CompatibleTime, _ = time.Parse(time.RFC3339, "1677-12-01T00:00:00Z")
+	MaxRFC3339CompatibleTime, _ = time.Parse(time.RFC3339, "2262-04-11T11:59:59Z")
+}
+
+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 := util.UnmarshalJSON(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(ctx context.Context, 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(ctx, 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() {
+		if !isDatetimeCompatible(q.Start) {
+			// overflow
+			return nil, nil, fmt.Errorf("invalid/unsupported date range, start: %v", q.Start)
+		}
+		startInt64 := q.Start.UnixNano()
+		min = numeric.Int64ToFloat64(startInt64)
+	}
+	if !q.End.IsZero() {
+		if !isDatetimeCompatible(q.End) {
+			// overflow
+			return nil, nil, fmt.Errorf("invalid/unsupported date range, end: %v", q.End)
+		}
+		endInt64 := q.End.UnixNano()
+		max = numeric.Int64ToFloat64(endInt64)
+	}
+
+	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
+}
+
+func isDatetimeCompatible(t BleveQueryTime) bool {
+	if QueryDateTimeFormat == time.RFC3339 &&
+		(t.Before(MinRFC3339CompatibleTime) || t.After(MaxRFC3339CompatibleTime)) {
+		return false
+	}
+
+	return true
+}

search/query/date_range_string.go

@@ -0,0 +1,176 @@
+//  Copyright (c) 2023 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 (
+	"context"
+	"fmt"
+	"math"
+	"time"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/numeric"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+// DateRangeStringQuery represents a query for a range of date values.
+// Start and End are the range endpoints, as strings.
+// Start and End are parsed using DateTimeParser, which is a custom date time parser
+// defined in the index mapping. If DateTimeParser is not specified, then the
+// top-level config.QueryDateTimeParser is used.
+type DateRangeStringQuery struct {
+	Start          string `json:"start,omitempty"`
+	End            string `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"`
+	DateTimeParser string `json:"datetime_parser,omitempty"`
+}
+
+// NewDateRangeStringQuery creates a new Query for ranges
+// of date values.
+// Date strings are parsed using the DateTimeParser field of the query struct,
+// which is a custom date time parser defined in the index mapping.
+// if DateTimeParser is not specified, then the
+// top-level config.QueryDateTimeParser is used.
+// Either, but not both endpoints can be nil.
+func NewDateRangeStringQuery(start, end string) *DateRangeStringQuery {
+	return NewDateRangeStringInclusiveQuery(start, end, nil, nil)
+}
+
+// NewDateRangeStringInclusiveQuery creates a new Query for ranges
+// of date values.
+// Date strings are parsed using the DateTimeParser field of the query struct,
+// which is a custom date time parser defined in the index mapping.
+// if DateTimeParser is not specified, then the
+// top-level config.QueryDateTimeParser is used.
+// Either, but not both endpoints can be nil.
+// startInclusive and endInclusive control inclusion of the endpoints.
+func NewDateRangeStringInclusiveQuery(start, end string, startInclusive, endInclusive *bool) *DateRangeStringQuery {
+	return &DateRangeStringQuery{
+		Start:          start,
+		End:            end,
+		InclusiveStart: startInclusive,
+		InclusiveEnd:   endInclusive,
+	}
+}
+
+func (q *DateRangeStringQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *DateRangeStringQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *DateRangeStringQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *DateRangeStringQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *DateRangeStringQuery) SetDateTimeParser(d string) {
+	q.DateTimeParser = d
+}
+
+func (q *DateRangeStringQuery) DateTimeParserName() string {
+	return q.DateTimeParser
+}
+
+func (q *DateRangeStringQuery) Searcher(ctx context.Context, i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+
+	dateTimeParserName := QueryDateTimeParser
+	if q.DateTimeParser != "" {
+		dateTimeParserName = q.DateTimeParser
+	}
+	dateTimeParser := m.DateTimeParserNamed(dateTimeParserName)
+	if dateTimeParser == nil {
+		return nil, fmt.Errorf("no dateTimeParser named '%s' registered", dateTimeParserName)
+	}
+
+	var startTime, endTime time.Time
+	var err error
+	if q.Start != "" {
+		startTime, _, err = dateTimeParser.ParseDateTime(q.Start)
+		if err != nil {
+			return nil, fmt.Errorf("%v, date time parser name: %s", err, dateTimeParserName)
+		}
+	}
+	if q.End != "" {
+		endTime, _, err = dateTimeParser.ParseDateTime(q.End)
+		if err != nil {
+			return nil, fmt.Errorf("%v, date time parser name: %s", err, dateTimeParserName)
+		}
+	}
+
+	min, max, err := q.parseEndpoints(startTime, endTime)
+	if err != nil {
+		return nil, err
+	}
+	return searcher.NewNumericRangeSearcher(ctx, i, min, max, q.InclusiveStart, q.InclusiveEnd, field, q.BoostVal.Value(), options)
+}
+
+func (q *DateRangeStringQuery) parseEndpoints(startTime, endTime time.Time) (*float64, *float64, error) {
+	min := math.Inf(-1)
+	max := math.Inf(1)
+
+	if startTime.IsZero() && endTime.IsZero() {
+		return nil, nil, fmt.Errorf("date range query must specify at least one of start/end")
+	}
+
+	if !startTime.IsZero() {
+		if !isDateTimeWithinRange(startTime) {
+			// overflow
+			return nil, nil, fmt.Errorf("invalid/unsupported date range, start: %v", q.Start)
+		}
+		startInt64 := startTime.UnixNano()
+		min = numeric.Int64ToFloat64(startInt64)
+	}
+	if !endTime.IsZero() {
+		if !isDateTimeWithinRange(endTime) {
+			// overflow
+			return nil, nil, fmt.Errorf("invalid/unsupported date range, end: %v", q.End)
+		}
+		endInt64 := endTime.UnixNano()
+		max = numeric.Int64ToFloat64(endInt64)
+	}
+
+	return &min, &max, nil
+}
+
+func (q *DateRangeStringQuery) Validate() error {
+	// either start or end must be specified
+	if q.Start == "" && q.End == "" {
+		return fmt.Errorf("date range query must specify at least one of start/end")
+	}
+	return nil
+}
+
+func isDateTimeWithinRange(t time.Time) bool {
+	if t.Before(MinRFC3339CompatibleTime) || t.After(MaxRFC3339CompatibleTime) {
+		return false
+	}
+	return true
+}

search/query/date_range_test.go

@@ -0,0 +1,132 @@
+//  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 (
+	"encoding/json"
+	"testing"
+	"time"
+)
+
+func TestBleveQueryTime(t *testing.T) {
+	testTimes := []time.Time{
+		time.Now(),
+		{},
+	}
+
+	for i, testTime := range testTimes {
+		bqt := &BleveQueryTime{testTime}
+
+		buf, err := json.Marshal(bqt)
+		if err != nil {
+			t.Errorf("expected no err")
+		}
+
+		var bqt2 BleveQueryTime
+		err = json.Unmarshal(buf, &bqt2)
+		if err != nil {
+			t.Errorf("expected no unmarshal err, got: %v", err)
+		}
+
+		if bqt.Time.Format(time.RFC3339) != bqt2.Time.Format(time.RFC3339) {
+			t.Errorf("test %d - expected same time, %#v != %#v", i, bqt.Time, bqt2.Time)
+		}
+
+		if testTime.Format(time.RFC3339) != bqt2.Time.Format(time.RFC3339) {
+			t.Errorf("test %d - expected orig time, %#v != %#v", i, testTime, bqt2.Time)
+		}
+	}
+}
+
+func TestValidateDatetimeRanges(t *testing.T) {
+	tests := []struct {
+		start  string
+		end    string
+		expect bool
+	}{
+		{
+			start:  "2019-03-22T13:25:00Z",
+			end:    "2019-03-22T18:25:00Z",
+			expect: true,
+		},
+		{
+			start:  "2019-03-22T13:25:00Z",
+			end:    "9999-03-22T13:25:00Z",
+			expect: false,
+		},
+		{
+			start:  "2019-03-22T13:25:00Z",
+			end:    "2262-04-11T11:59:59Z",
+			expect: true,
+		},
+		{
+			start:  "2019-03-22T13:25:00Z",
+			end:    "2262-04-12T00:00:00Z",
+			expect: false,
+		},
+		{
+			start:  "1950-03-22T12:23:23Z",
+			end:    "1960-02-21T15:23:34Z",
+			expect: true,
+		},
+		{
+			start:  "0001-01-01T00:00:00Z",
+			end:    "0001-01-01T00:00:00Z",
+			expect: false,
+		},
+		{
+			start:  "0001-01-01T00:00:00Z",
+			end:    "2000-01-01T00:00:00Z",
+			expect: true,
+		},
+		{
+			start:  "1677-11-30T11:59:59Z",
+			end:    "2262-04-11T11:59:59Z",
+			expect: false,
+		},
+		{
+			start:  "2262-04-12T00:00:00Z",
+			end:    "2262-04-11T11:59:59Z",
+			expect: false,
+		},
+		{
+			start:  "1677-12-01T00:00:00Z",
+			end:    "2262-04-12T00:00:00Z",
+			expect: false,
+		},
+		{
+			start:  "1677-12-01T00:00:00Z",
+			end:    "1677-11-30T11:59:59Z",
+			expect: false,
+		},
+		{
+			start:  "1677-12-01T00:00:00Z",
+			end:    "2262-04-11T11:59:59Z",
+			expect: true,
+		},
+	}
+
+	for _, test := range tests {
+		startTime, _ := time.Parse(time.RFC3339, test.start)
+		endTime, _ := time.Parse(time.RFC3339, test.end)
+
+		dateRangeQuery := NewDateRangeQuery(startTime, endTime)
+		if (dateRangeQuery.Validate() == nil) != test.expect {
+			t.Errorf("unexpected results while validating date range query with"+
+				" {start: %v, end: %v}, expected: %v",
+				test.start, test.end, test.expect)
+		}
+	}
+}

search/query/disjunction.go

@@ -0,0 +1,134 @@
+//  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 (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	"github.com/blevesearch/bleve/v2/util"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+type DisjunctionQuery struct {
+	Disjuncts              []Query `json:"disjuncts"`
+	BoostVal               *Boost  `json:"boost,omitempty"`
+	Min                    float64 `json:"min"`
+	retrieveScoreBreakdown bool
+	queryStringMode        bool
+}
+
+func (q *DisjunctionQuery) RetrieveScoreBreakdown(b bool) {
+	q.retrieveScoreBreakdown = b
+}
+
+// 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) {
+	q.Disjuncts = append(q.Disjuncts, aq...)
+}
+
+func (q *DisjunctionQuery) SetMin(m float64) {
+	q.Min = m
+}
+
+func (q *DisjunctionQuery) Searcher(ctx context.Context, 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(ctx, i, m, options)
+		if err != nil {
+			for _, searcher := range ss {
+				if searcher != nil {
+					_ = searcher.Close()
+				}
+			}
+			return nil, err
+		}
+		if sr != nil {
+			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)
+	}
+
+	nctx := context.WithValue(ctx, search.IncludeScoreBreakdownKey, q.retrieveScoreBreakdown)
+
+	return searcher.NewDisjunctionSearcher(nctx, 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 := util.UnmarshalJSON(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
+}

search/query/docid.go

@@ -0,0 +1,51 @@
+//  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 (
+	"context"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+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(ctx context.Context, i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	return searcher.NewDocIDSearcher(ctx, i, q.IDs, q.BoostVal.Value(), options)
+}

search/query/fuzzy.go

@@ -0,0 +1,134 @@
+//  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 (
+	"context"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	"github.com/blevesearch/bleve/v2/util"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+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"`
+	autoFuzzy bool
+}
+
+// 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) SetAutoFuzziness(a bool) {
+	q.autoFuzzy = a
+}
+
+func (q *FuzzyQuery) SetPrefix(p int) {
+	q.Prefix = p
+}
+
+func (q *FuzzyQuery) Searcher(ctx context.Context, i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+	if q.autoFuzzy {
+		return searcher.NewAutoFuzzySearcher(ctx, i, q.Term, q.Prefix, field, q.BoostVal.Value(), options)
+	}
+	return searcher.NewFuzzySearcher(ctx, i, q.Term, q.Prefix, q.Fuzziness, field, q.BoostVal.Value(), options)
+}
+
+func (q *FuzzyQuery) UnmarshalJSON(data []byte) error {
+	type Alias FuzzyQuery
+	aux := &struct {
+		Fuzziness interface{} `json:"fuzziness"`
+		*Alias
+	}{
+		Alias: (*Alias)(q),
+	}
+	if err := util.UnmarshalJSON(data, &aux); err != nil {
+		return err
+	}
+	switch v := aux.Fuzziness.(type) {
+	case float64:
+		q.Fuzziness = int(v)
+	case string:
+		if v == "auto" {
+			q.autoFuzzy = true
+		}
+	}
+	return nil
+}
+
+func (f *FuzzyQuery) MarshalJSON() ([]byte, error) {
+	var fuzzyValue interface{}
+	if f.autoFuzzy {
+		fuzzyValue = "auto"
+	} else {
+		fuzzyValue = f.Fuzziness
+	}
+	type fuzzyQuery struct {
+		Term      string      `json:"term"`
+		Prefix    int         `json:"prefix_length"`
+		Fuzziness interface{} `json:"fuzziness"`
+		FieldVal  string      `json:"field,omitempty"`
+		BoostVal  *Boost      `json:"boost,omitempty"`
+	}
+	aux := fuzzyQuery{
+		Term:      f.Term,
+		Prefix:    f.Prefix,
+		Fuzziness: fuzzyValue,
+		FieldVal:  f.FieldVal,
+		BoostVal:  f.BoostVal,
+	}
+	return util.MarshalJSON(aux)
+}

search/query/geo_boundingbox.go

@@ -0,0 +1,119 @@
+//  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 (
+	"context"
+	"fmt"
+
+	"github.com/blevesearch/bleve/v2/geo"
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	"github.com/blevesearch/bleve/v2/util"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+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(ctx context.Context, i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+
+	ctx = context.WithValue(ctx, search.QueryTypeKey, search.Geo)
+
+	if q.BottomRight[0] < q.TopLeft[0] {
+		// cross date line, rewrite as two parts
+
+		leftSearcher, err := searcher.NewGeoBoundingBoxSearcher(ctx, 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(ctx, 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(ctx, i, []search.Searcher{leftSearcher, rightSearcher}, 0, options)
+	}
+
+	return searcher.NewGeoBoundingBoxSearcher(ctx, i, q.TopLeft[0], q.BottomRight[1], q.BottomRight[0], q.TopLeft[1], field, q.BoostVal.Value(), options, true)
+}
+
+func (q *GeoBoundingBoxQuery) Validate() error {
+	if q.TopLeft[1] < q.BottomRight[1] {
+		return fmt.Errorf("geo bounding box top left should be higher than bottom right")
+	}
+	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 := util.UnmarshalJSON(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
+}

search/query/geo_boundingpolygon.go

@@ -0,0 +1,97 @@
+//  Copyright (c) 2019 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 (
+	"context"
+	"fmt"
+
+	"github.com/blevesearch/bleve/v2/geo"
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	"github.com/blevesearch/bleve/v2/util"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+type GeoBoundingPolygonQuery struct {
+	Points   []geo.Point `json:"polygon_points"`
+	FieldVal string      `json:"field,omitempty"`
+	BoostVal *Boost      `json:"boost,omitempty"`
+}
+
+func NewGeoBoundingPolygonQuery(points []geo.Point) *GeoBoundingPolygonQuery {
+	return &GeoBoundingPolygonQuery{
+		Points: points}
+}
+
+func (q *GeoBoundingPolygonQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *GeoBoundingPolygonQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *GeoBoundingPolygonQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *GeoBoundingPolygonQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *GeoBoundingPolygonQuery) Searcher(ctx context.Context, i index.IndexReader,
+	m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+
+	ctx = context.WithValue(ctx, search.QueryTypeKey, search.Geo)
+
+	return searcher.NewGeoBoundedPolygonSearcher(ctx, i, q.Points, field, q.BoostVal.Value(), options)
+}
+
+func (q *GeoBoundingPolygonQuery) Validate() error {
+	return nil
+}
+
+func (q *GeoBoundingPolygonQuery) UnmarshalJSON(data []byte) error {
+	tmp := struct {
+		Points   []interface{} `json:"polygon_points"`
+		FieldVal string        `json:"field,omitempty"`
+		BoostVal *Boost        `json:"boost,omitempty"`
+	}{}
+	err := util.UnmarshalJSON(data, &tmp)
+	if err != nil {
+		return err
+	}
+
+	q.Points = make([]geo.Point, 0, len(tmp.Points))
+	for _, i := range tmp.Points {
+		// now use our generic point parsing code from the geo package
+		lon, lat, found := geo.ExtractGeoPoint(i)
+		if !found {
+			return fmt.Errorf("geo polygon point: %v is not in a valid format", i)
+		}
+		q.Points = append(q.Points, geo.Point{Lon: lon, Lat: lat})
+	}
+
+	q.FieldVal = tmp.FieldVal
+	q.BoostVal = tmp.BoostVal
+	return nil
+}

search/query/geo_distance.go

@@ -0,0 +1,103 @@
+//  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 (
+	"context"
+	"fmt"
+
+	"github.com/blevesearch/bleve/v2/geo"
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	"github.com/blevesearch/bleve/v2/util"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+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(ctx context.Context, i index.IndexReader, m mapping.IndexMapping,
+	options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+
+	ctx = context.WithValue(ctx, search.QueryTypeKey, search.Geo)
+
+	dist, err := geo.ParseDistance(q.Distance)
+	if err != nil {
+		return nil, err
+	}
+
+	return searcher.NewGeoPointDistanceSearcher(ctx, 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 := util.UnmarshalJSON(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
+}

search/query/geo_shape.go

@@ -0,0 +1,138 @@
+//  Copyright (c) 2022 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 (
+	"context"
+	"encoding/json"
+
+	"github.com/blevesearch/bleve/v2/geo"
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	"github.com/blevesearch/bleve/v2/util"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+type Geometry struct {
+	Shape    index.GeoJSON `json:"shape"`
+	Relation string        `json:"relation"`
+}
+
+type GeoShapeQuery struct {
+	Geometry Geometry `json:"geometry"`
+	FieldVal string   `json:"field,omitempty"`
+	BoostVal *Boost   `json:"boost,omitempty"`
+}
+
+// NewGeoShapeQuery creates a geoshape query for the
+// given shape type. This method can be used for
+// creating geoshape queries for shape types like: point,
+// linestring, polygon, multipoint, multilinestring,
+// multipolygon and envelope.
+func NewGeoShapeQuery(coordinates [][][][]float64, typ,
+	relation string) (*GeoShapeQuery, error) {
+	s, _, err := geo.NewGeoJsonShape(coordinates, typ)
+	if err != nil {
+		return nil, err
+	}
+
+	return &GeoShapeQuery{Geometry: Geometry{Shape: s,
+		Relation: relation}}, nil
+}
+
+// NewGeoShapeCircleQuery creates a geoshape query for the
+// given center point and the radius. Radius formats supported:
+// "5in" "5inch" "7yd" "7yards" "9ft" "9feet" "11km" "11kilometers"
+// "3nm" "3nauticalmiles" "13mm" "13millimeters" "15cm" "15centimeters"
+// "17mi" "17miles" "19m" "19meters" If the unit cannot be determined,
+// the entire string is parsed and the unit of meters is assumed.
+func NewGeoShapeCircleQuery(coordinates []float64, radius,
+	relation string) (*GeoShapeQuery, error) {
+
+	s, _, err := geo.NewGeoCircleShape(coordinates, radius)
+	if err != nil {
+		return nil, err
+	}
+
+	return &GeoShapeQuery{Geometry: Geometry{Shape: s,
+		Relation: relation}}, nil
+}
+
+// NewGeometryCollectionQuery creates a geoshape query for the
+// given geometrycollection coordinates and types.
+func NewGeometryCollectionQuery(coordinates [][][][][]float64, types []string,
+	relation string) (*GeoShapeQuery, error) {
+	s, _, err := geo.NewGeometryCollection(coordinates, types)
+	if err != nil {
+		return nil, err
+	}
+
+	return &GeoShapeQuery{Geometry: Geometry{Shape: s,
+		Relation: relation}}, nil
+}
+
+func (q *GeoShapeQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *GeoShapeQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *GeoShapeQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *GeoShapeQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *GeoShapeQuery) Searcher(ctx context.Context, i index.IndexReader,
+	m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+
+	ctx = context.WithValue(ctx, search.QueryTypeKey, search.Geo)
+
+	return searcher.NewGeoShapeSearcher(ctx, i, q.Geometry.Shape, q.Geometry.Relation, field,
+		q.BoostVal.Value(), options)
+}
+
+func (q *GeoShapeQuery) Validate() error {
+	return nil
+}
+
+func (q *Geometry) UnmarshalJSON(data []byte) error {
+	tmp := struct {
+		Shape    json.RawMessage `json:"shape"`
+		Relation string          `json:"relation"`
+	}{}
+
+	err := util.UnmarshalJSON(data, &tmp)
+	if err != nil {
+		return err
+	}
+
+	q.Shape, err = geo.ParseGeoJSONShape(tmp.Shape)
+	if err != nil {
+		return err
+	}
+	q.Relation = tmp.Relation
+	return nil
+}

search/query/ip_range.go

@@ -0,0 +1,85 @@
+//  Copyright (c) 2021 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 (
+	"context"
+	"fmt"
+	"net"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+type IPRangeQuery struct {
+	CIDR     string `json:"cidr,omitempty"`
+	FieldVal string `json:"field,omitempty"`
+	BoostVal *Boost `json:"boost,omitempty"`
+}
+
+func NewIPRangeQuery(cidr string) *IPRangeQuery {
+	return &IPRangeQuery{
+		CIDR: cidr,
+	}
+}
+
+func (q *IPRangeQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *IPRangeQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *IPRangeQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *IPRangeQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *IPRangeQuery) Searcher(ctx context.Context, i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+	_, ipNet, err := net.ParseCIDR(q.CIDR)
+	if err != nil {
+		ip := net.ParseIP(q.CIDR)
+		if ip == nil {
+			return nil, err
+		}
+		// If we are searching for a specific ip rather than members of a network, just use a term search.
+		return searcher.NewTermSearcherBytes(ctx, i, ip.To16(), field, q.BoostVal.Value(), options)
+	}
+	return searcher.NewIPRangeSearcher(ctx, i, ipNet, field, q.BoostVal.Value(), options)
+}
+
+func (q *IPRangeQuery) Validate() error {
+	_, _, err := net.ParseCIDR(q.CIDR)
+	if err == nil {
+		return nil
+	}
+	// We also allow search for a specific IP.
+	ip := net.ParseIP(q.CIDR)
+	if ip != nil {
+		return nil // we have a valid ip
+	}
+	return fmt.Errorf("IPRangeQuery must be for a network or ip address, %q", q.CIDR)
+}

search/query/knn.go

@@ -0,0 +1,95 @@
+//  Copyright (c) 2023 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.
+
+//go:build vectors
+// +build vectors
+
+package query
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+type KNNQuery struct {
+	VectorField string    `json:"field"`
+	Vector      []float32 `json:"vector"`
+	K           int64     `json:"k"`
+	BoostVal    *Boost    `json:"boost,omitempty"`
+
+	// see KNNRequest.Params for description
+	Params json.RawMessage `json:"params"`
+	// elegibleSelector is used to filter out documents that are
+	// eligible for the KNN search from a pre-filter query.
+	elegibleSelector index.EligibleDocumentSelector
+}
+
+func NewKNNQuery(vector []float32) *KNNQuery {
+	return &KNNQuery{Vector: vector}
+}
+
+func (q *KNNQuery) Field() string {
+	return q.VectorField
+}
+
+func (q *KNNQuery) SetK(k int64) {
+	q.K = k
+}
+
+func (q *KNNQuery) SetFieldVal(field string) {
+	q.VectorField = field
+}
+
+func (q *KNNQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *KNNQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *KNNQuery) SetParams(params json.RawMessage) {
+	q.Params = params
+}
+
+func (q *KNNQuery) SetEligibleSelector(eligibleSelector index.EligibleDocumentSelector) {
+	q.elegibleSelector = eligibleSelector
+}
+
+func (q *KNNQuery) Searcher(ctx context.Context, i index.IndexReader,
+	m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	fieldMapping := m.FieldMappingForPath(q.VectorField)
+	similarityMetric := fieldMapping.Similarity
+	if similarityMetric == "" {
+		similarityMetric = index.DefaultVectorSimilarityMetric
+	}
+	if q.K <= 0 || len(q.Vector) == 0 {
+		return nil, fmt.Errorf("k must be greater than 0 and vector must be non-empty")
+	}
+	if similarityMetric == index.CosineSimilarity {
+		// normalize the vector
+		q.Vector = mapping.NormalizeVector(q.Vector)
+	}
+
+	return searcher.NewKNNSearcher(ctx, i, m, options, q.VectorField,
+		q.Vector, q.K, q.BoostVal.Value(), similarityMetric, q.Params,
+		q.elegibleSelector)
+}

search/query/match.go

@@ -0,0 +1,236 @@
+//  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 (
+	"context"
+	"fmt"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/util"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+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"`
+	autoFuzzy bool
+}
+
+type MatchQueryOperator int
+
+const (
+	// Document must satisfy AT LEAST ONE of term searches.
+	MatchQueryOperatorOr = MatchQueryOperator(0)
+	// Document must satisfy ALL of term searches.
+	MatchQueryOperatorAnd = MatchQueryOperator(1)
+)
+
+func (o MatchQueryOperator) MarshalJSON() ([]byte, error) {
+	switch o {
+	case MatchQueryOperatorOr:
+		return util.MarshalJSON("or")
+	case MatchQueryOperatorAnd:
+		return util.MarshalJSON("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 := util.UnmarshalJSON(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) SetAutoFuzziness(auto bool) {
+	q.autoFuzzy = auto
+}
+
+func (q *MatchQuery) SetPrefix(p int) {
+	q.Prefix = p
+}
+
+func (q *MatchQuery) SetOperator(operator MatchQueryOperator) {
+	q.Operator = operator
+}
+
+func (q *MatchQuery) Searcher(ctx context.Context, 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 || q.autoFuzzy {
+			for i, token := range tokens {
+				query := NewFuzzyQuery(string(token.Term))
+				if q.autoFuzzy {
+					query.SetAutoFuzziness(true)
+				} else {
+					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(ctx, i, m, options)
+
+		case MatchQueryOperatorAnd:
+			mustQuery := NewConjunctionQuery(tqs)
+			mustQuery.SetBoost(q.BoostVal.Value())
+			return mustQuery.Searcher(ctx, i, m, options)
+
+		default:
+			return nil, fmt.Errorf("unhandled operator %d", q.Operator)
+		}
+	}
+	noneQuery := NewMatchNoneQuery()
+	return noneQuery.Searcher(ctx, i, m, options)
+}
+
+func (q *MatchQuery) UnmarshalJSON(data []byte) error {
+	type Alias MatchQuery
+	aux := &struct {
+		Fuzziness interface{} `json:"fuzziness"`
+		*Alias
+	}{
+		Alias: (*Alias)(q),
+	}
+	if err := util.UnmarshalJSON(data, &aux); err != nil {
+		return err
+	}
+	switch v := aux.Fuzziness.(type) {
+	case float64:
+		q.Fuzziness = int(v)
+	case string:
+		if v == "auto" {
+			q.autoFuzzy = true
+		}
+	}
+	return nil
+}
+
+func (f *MatchQuery) MarshalJSON() ([]byte, error) {
+	var fuzzyValue interface{}
+	if f.autoFuzzy {
+		fuzzyValue = "auto"
+	} else {
+		fuzzyValue = f.Fuzziness
+	}
+	type match 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 interface{}        `json:"fuzziness"`
+		Operator  MatchQueryOperator `json:"operator,omitempty"`
+	}
+	aux := match{
+		Match:     f.Match,
+		FieldVal:  f.FieldVal,
+		Analyzer:  f.Analyzer,
+		BoostVal:  f.BoostVal,
+		Prefix:    f.Prefix,
+		Fuzziness: fuzzyValue,
+		Operator:  f.Operator,
+	}
+	return util.MarshalJSON(aux)
+}

search/query/match_all.go

@@ -0,0 +1,56 @@
+//  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 (
+	"context"
+	"encoding/json"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+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(ctx context.Context, i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	return searcher.NewMatchAllSearcher(ctx, 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)
+}

search/query/match_none.go

@@ -0,0 +1,56 @@
+//  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 (
+	"context"
+	"encoding/json"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+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(ctx context.Context, 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)
+}

search/query/match_phrase.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 (
+	"context"
+	"fmt"
+
+	"github.com/blevesearch/bleve/v2/analysis"
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/util"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+type MatchPhraseQuery struct {
+	MatchPhrase string `json:"match_phrase"`
+	FieldVal    string `json:"field,omitempty"`
+	Analyzer    string `json:"analyzer,omitempty"`
+	BoostVal    *Boost `json:"boost,omitempty"`
+	Fuzziness   int    `json:"fuzziness"`
+	autoFuzzy   bool
+}
+
+// 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) SetFuzziness(f int) {
+	q.Fuzziness = f
+}
+
+func (q *MatchPhraseQuery) SetAutoFuzziness(auto bool) {
+	q.autoFuzzy = auto
+}
+
+func (q *MatchPhraseQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *MatchPhraseQuery) Searcher(ctx context.Context, 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())
+		if q.autoFuzzy {
+			phraseQuery.SetAutoFuzziness(true)
+		} else {
+			phraseQuery.SetFuzziness(q.Fuzziness)
+		}
+		return phraseQuery.Searcher(ctx, i, m, options)
+	}
+	noneQuery := NewMatchNoneQuery()
+	return noneQuery.Searcher(ctx, 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
+}
+
+func (q *MatchPhraseQuery) UnmarshalJSON(data []byte) error {
+	type Alias MatchPhraseQuery
+	aux := &struct {
+		Fuzziness interface{} `json:"fuzziness"`
+		*Alias
+	}{
+		Alias: (*Alias)(q),
+	}
+	if err := util.UnmarshalJSON(data, &aux); err != nil {
+		return err
+	}
+	switch v := aux.Fuzziness.(type) {
+	case float64:
+		q.Fuzziness = int(v)
+	case string:
+		if v == "auto" {
+			q.autoFuzzy = true
+		}
+	}
+	return nil
+}
+
+func (f *MatchPhraseQuery) MarshalJSON() ([]byte, error) {
+	var fuzzyValue interface{}
+	if f.autoFuzzy {
+		fuzzyValue = "auto"
+	} else {
+		fuzzyValue = f.Fuzziness
+	}
+	type matchPhrase struct {
+		MatchPhrase string      `json:"match_phrase"`
+		FieldVal    string      `json:"field,omitempty"`
+		Analyzer    string      `json:"analyzer,omitempty"`
+		BoostVal    *Boost      `json:"boost,omitempty"`
+		Fuzziness   interface{} `json:"fuzziness"`
+	}
+	aux := matchPhrase{
+		MatchPhrase: f.MatchPhrase,
+		FieldVal:    f.FieldVal,
+		Analyzer:    f.Analyzer,
+		BoostVal:    f.BoostVal,
+		Fuzziness:   fuzzyValue,
+	}
+	return util.MarshalJSON(aux)
+}

search/query/match_phrase_test.go

@@ -0,0 +1,101 @@
+//  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 (
+	"reflect"
+	"testing"
+
+	"github.com/blevesearch/bleve/v2/analysis"
+)
+
+func TestTokenStreamToPhrase(t *testing.T) {
+
+	tests := []struct {
+		tokens analysis.TokenStream
+		result [][]string
+	}{
+		// empty token stream returns nil
+		{
+			tokens: analysis.TokenStream{},
+			result: nil,
+		},
+		// typical token
+		{
+			tokens: analysis.TokenStream{
+				&analysis.Token{
+					Term:     []byte("one"),
+					Position: 1,
+				},
+				&analysis.Token{
+					Term:     []byte("two"),
+					Position: 2,
+				},
+			},
+			result: [][]string{{"one"}, {"two"}},
+		},
+		// token stream containing a gap (usually from stop words)
+		{
+			tokens: analysis.TokenStream{
+				&analysis.Token{
+					Term:     []byte("wag"),
+					Position: 1,
+				},
+				&analysis.Token{
+					Term:     []byte("dog"),
+					Position: 3,
+				},
+			},
+			result: [][]string{{"wag"}, nil, {"dog"}},
+		},
+		// token stream containing multiple tokens at the same position
+		{
+			tokens: analysis.TokenStream{
+				&analysis.Token{
+					Term:     []byte("nia"),
+					Position: 1,
+				},
+				&analysis.Token{
+					Term:     []byte("onia"),
+					Position: 1,
+				},
+				&analysis.Token{
+					Term:     []byte("donia"),
+					Position: 1,
+				},
+				&analysis.Token{
+					Term:     []byte("imo"),
+					Position: 2,
+				},
+				&analysis.Token{
+					Term:     []byte("nimo"),
+					Position: 2,
+				},
+				&analysis.Token{
+					Term:     []byte("ónimo"),
+					Position: 2,
+				},
+			},
+			result: [][]string{{"nia", "onia", "donia"}, {"imo", "nimo", "ónimo"}},
+		},
+	}
+
+	for i, test := range tests {
+		actual := tokenStreamToPhrase(test.tokens)
+		if !reflect.DeepEqual(actual, test.result) {
+			t.Fatalf("expected %#v got %#v for test %d", test.result, actual, i)
+		}
+	}
+}

search/query/multi_phrase.go

@@ -0,0 +1,130 @@
+//  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 (
+	"context"
+	"fmt"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	"github.com/blevesearch/bleve/v2/util"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+type MultiPhraseQuery struct {
+	Terms     [][]string `json:"terms"`
+	FieldVal  string     `json:"field,omitempty"`
+	BoostVal  *Boost     `json:"boost,omitempty"`
+	Fuzziness int        `json:"fuzziness"`
+	autoFuzzy bool
+}
+
+// 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,
+		FieldVal: field,
+	}
+}
+
+func (q *MultiPhraseQuery) SetFuzziness(f int) {
+	q.Fuzziness = f
+}
+
+func (q *MultiPhraseQuery) SetAutoFuzziness(auto bool) {
+	q.autoFuzzy = auto
+}
+
+func (q *MultiPhraseQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *MultiPhraseQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *MultiPhraseQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *MultiPhraseQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *MultiPhraseQuery) Searcher(ctx context.Context, i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	return searcher.NewMultiPhraseSearcher(ctx, i, q.Terms, q.Fuzziness, q.autoFuzzy, q.FieldVal, q.BoostVal.Value(), 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 Alias MultiPhraseQuery
+	aux := &struct {
+		Fuzziness interface{} `json:"fuzziness"`
+		*Alias
+	}{
+		Alias: (*Alias)(q),
+	}
+	if err := util.UnmarshalJSON(data, &aux); err != nil {
+		return err
+	}
+	switch v := aux.Fuzziness.(type) {
+	case float64:
+		q.Fuzziness = int(v)
+	case string:
+		if v == "auto" {
+			q.autoFuzzy = true
+		}
+	}
+	return nil
+}
+
+func (f *MultiPhraseQuery) MarshalJSON() ([]byte, error) {
+	var fuzzyValue interface{}
+	if f.autoFuzzy {
+		fuzzyValue = "auto"
+	} else {
+		fuzzyValue = f.Fuzziness
+	}
+	type multiPhraseQuery struct {
+		Terms     [][]string  `json:"terms"`
+		FieldVal  string      `json:"field,omitempty"`
+		BoostVal  *Boost      `json:"boost,omitempty"`
+		Fuzziness interface{} `json:"fuzziness"`
+	}
+	aux := multiPhraseQuery{
+		Terms:     f.Terms,
+		FieldVal:  f.FieldVal,
+		BoostVal:  f.BoostVal,
+		Fuzziness: fuzzyValue,
+	}
+	return util.MarshalJSON(aux)
+}

search/query/numeric_range.go

@@ -0,0 +1,89 @@
+//  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 (
+	"context"
+	"fmt"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+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(ctx context.Context, i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+	ctx = context.WithValue(ctx, search.QueryTypeKey, search.Numeric)
+	return searcher.NewNumericRangeSearcher(ctx, 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
+}

search/query/phrase.go

@@ -0,0 +1,127 @@
+//  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 (
+	"context"
+	"fmt"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	"github.com/blevesearch/bleve/v2/util"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+type PhraseQuery struct {
+	Terms     []string `json:"terms"`
+	FieldVal  string   `json:"field,omitempty"`
+	BoostVal  *Boost   `json:"boost,omitempty"`
+	Fuzziness int      `json:"fuzziness"`
+	autoFuzzy bool
+}
+
+// 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,
+		FieldVal: field,
+	}
+}
+
+func (q *PhraseQuery) SetBoost(b float64) {
+	boost := Boost(b)
+	q.BoostVal = &boost
+}
+
+func (q *PhraseQuery) SetFuzziness(f int) {
+	q.Fuzziness = f
+}
+
+func (q *PhraseQuery) SetAutoFuzziness(auto bool) {
+	q.autoFuzzy = auto
+}
+
+func (q *PhraseQuery) Boost() float64 {
+	return q.BoostVal.Value()
+}
+
+func (q *PhraseQuery) SetField(f string) {
+	q.FieldVal = f
+}
+
+func (q *PhraseQuery) Field() string {
+	return q.FieldVal
+}
+
+func (q *PhraseQuery) Searcher(ctx context.Context, i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	return searcher.NewPhraseSearcher(ctx, i, q.Terms, q.Fuzziness, q.autoFuzzy, q.FieldVal, q.BoostVal.Value(), 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 Alias PhraseQuery
+	aux := &struct {
+		Fuzziness interface{} `json:"fuzziness"`
+		*Alias
+	}{
+		Alias: (*Alias)(q),
+	}
+	if err := util.UnmarshalJSON(data, &aux); err != nil {
+		return err
+	}
+	switch v := aux.Fuzziness.(type) {
+	case float64:
+		q.Fuzziness = int(v)
+	case string:
+		if v == "auto" {
+			q.autoFuzzy = true
+		}
+	}
+	return nil
+}
+
+func (f *PhraseQuery) MarshalJSON() ([]byte, error) {
+	var fuzzyValue interface{}
+	if f.autoFuzzy {
+		fuzzyValue = "auto"
+	} else {
+		fuzzyValue = f.Fuzziness
+	}
+	type phraseQuery struct {
+		Terms     []string    `json:"terms"`
+		FieldVal  string      `json:"field,omitempty"`
+		BoostVal  *Boost      `json:"boost,omitempty"`
+		Fuzziness interface{} `json:"fuzziness"`
+	}
+	aux := phraseQuery{
+		Terms:     f.Terms,
+		FieldVal:  f.FieldVal,
+		BoostVal:  f.BoostVal,
+		Fuzziness: fuzzyValue,
+	}
+	return util.MarshalJSON(aux)
+}

search/query/prefix.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 (
+	"context"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+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(ctx context.Context, i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+	return searcher.NewTermPrefixSearcher(ctx, i, q.Prefix, field, q.BoostVal.Value(), options)
+}

search/query/query.go

@@ -0,0 +1,783 @@
+//  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 (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"strings"
+
+	"github.com/blevesearch/bleve/v2/analysis"
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	"github.com/blevesearch/bleve/v2/util"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+var logger = log.New(io.Discard, "bleve mapping ", log.LstdFlags)
+
+// SetLog sets the logger used for logging
+// by default log messages are sent to io.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(ctx context.Context, 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
+}
+
+// ParsePreSearchData deserializes a JSON representation of
+// a PreSearchData object.
+func ParsePreSearchData(input []byte) (map[string]interface{}, error) {
+	var rv map[string]interface{}
+
+	var tmp map[string]json.RawMessage
+	err := util.UnmarshalJSON(input, &tmp)
+	if err != nil {
+		return nil, err
+	}
+
+	for k, v := range tmp {
+		switch k {
+		case search.KnnPreSearchDataKey:
+			var value []*search.DocumentMatch
+			if v != nil {
+				err := util.UnmarshalJSON(v, &value)
+				if err != nil {
+					return nil, err
+				}
+			}
+			if rv == nil {
+				rv = make(map[string]interface{})
+			}
+			rv[search.KnnPreSearchDataKey] = value
+		case search.SynonymPreSearchDataKey:
+			var value search.FieldTermSynonymMap
+			if v != nil {
+				err := util.UnmarshalJSON(v, &value)
+				if err != nil {
+					return nil, err
+				}
+			}
+			if rv == nil {
+				rv = make(map[string]interface{})
+			}
+			rv[search.SynonymPreSearchDataKey] = value
+		case search.BM25PreSearchDataKey:
+			var value *search.BM25Stats
+			if v != nil {
+				err := util.UnmarshalJSON(v, &value)
+				if err != nil {
+					return nil, err
+				}
+			}
+			if rv == nil {
+				rv = make(map[string]interface{})
+			}
+			rv[search.BM25PreSearchDataKey] = value
+
+		}
+	}
+	return rv, nil
+}
+
+// ParseQuery deserializes a JSON representation of
+// a Query object.
+func ParseQuery(input []byte) (Query, error) {
+	if len(input) == 0 {
+		// interpret as a match_none query
+		return NewMatchNoneQuery(), nil
+	}
+
+	var tmp map[string]interface{}
+	err := util.UnmarshalJSON(input, &tmp)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(tmp) == 0 {
+		// interpret as a match_none query
+		return NewMatchNoneQuery(), nil
+	}
+
+	_, hasFuzziness := tmp["fuzziness"]
+	_, isMatchQuery := tmp["match"]
+	_, isMatchPhraseQuery := tmp["match_phrase"]
+	_, hasTerms := tmp["terms"]
+	if hasFuzziness && !isMatchQuery && !isMatchPhraseQuery && !hasTerms {
+		var rv FuzzyQuery
+		err := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	if isMatchQuery {
+		var rv MatchQuery
+		err := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	if isMatchPhraseQuery {
+		var rv MatchPhraseQuery
+		err := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	if hasTerms {
+		var rv PhraseQuery
+		err := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			// now try multi-phrase
+			var rv2 MultiPhraseQuery
+			err = util.UnmarshalJSON(input, &rv2)
+			if err != nil {
+				return nil, err
+			}
+			return &rv2, nil
+		}
+		return &rv, nil
+	}
+	_, isTermQuery := tmp["term"]
+	if isTermQuery {
+		var rv TermQuery
+		err := util.UnmarshalJSON(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 := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasConjuncts := tmp["conjuncts"]
+	if hasConjuncts {
+		var rv ConjunctionQuery
+		err := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasDisjuncts := tmp["disjuncts"]
+	if hasDisjuncts {
+		var rv DisjunctionQuery
+		err := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+
+	_, hasSyntaxQuery := tmp["query"]
+	if hasSyntaxQuery {
+		var rv QueryStringQuery
+		err := util.UnmarshalJSON(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 := util.UnmarshalJSON(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 := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasStart := tmp["start"]
+	_, hasEnd := tmp["end"]
+	if hasStart || hasEnd {
+		var rv DateRangeStringQuery
+		err := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasPrefix := tmp["prefix"]
+	if hasPrefix {
+		var rv PrefixQuery
+		err := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasRegexp := tmp["regexp"]
+	if hasRegexp {
+		var rv RegexpQuery
+		err := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasWildcard := tmp["wildcard"]
+	if hasWildcard {
+		var rv WildcardQuery
+		err := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasMatchAll := tmp["match_all"]
+	if hasMatchAll {
+		var rv MatchAllQuery
+		err := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasMatchNone := tmp["match_none"]
+	if hasMatchNone {
+		var rv MatchNoneQuery
+		err := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasDocIds := tmp["ids"]
+	if hasDocIds {
+		var rv DocIDQuery
+		err := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasBool := tmp["bool"]
+	if hasBool {
+		var rv BoolFieldQuery
+		err := util.UnmarshalJSON(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 := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasDistance := tmp["distance"]
+	if hasDistance {
+		var rv GeoDistanceQuery
+		err := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+	_, hasPoints := tmp["polygon_points"]
+	if hasPoints {
+		var rv GeoBoundingPolygonQuery
+		err := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+
+	_, hasGeo := tmp["geometry"]
+	if hasGeo {
+		var rv GeoShapeQuery
+		err := util.UnmarshalJSON(input, &rv)
+		if err != nil {
+			return nil, err
+		}
+		return &rv, nil
+	}
+
+	_, hasCIDR := tmp["cidr"]
+	if hasCIDR {
+		var rv IPRangeQuery
+		err := util.UnmarshalJSON(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) = 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 q := query.(type) {
+		case *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:
+			children, err := expandSlice(q.Conjuncts)
+			if err != nil {
+				return nil, err
+			}
+			q.Conjuncts = children
+			return q, nil
+		case *DisjunctionQuery:
+			children, err := expandSlice(q.Disjuncts)
+			if err != nil {
+				return nil, err
+			}
+			q.Disjuncts = children
+			return q, nil
+		case *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
+}
+
+// FieldSet represents a set of queried fields.
+type FieldSet map[string]struct{}
+
+// ExtractFields returns a set of fields referenced by the query.
+// The returned set may be nil if the query does not explicitly reference any field
+// and the DefaultSearchField is unset in the index mapping.
+func ExtractFields(q Query, m mapping.IndexMapping, fs FieldSet) (FieldSet, error) {
+	if q == nil || m == nil {
+		return fs, nil
+	}
+	var err error
+	switch q := q.(type) {
+	case FieldableQuery:
+		f := q.Field()
+		if f == "" {
+			f = m.DefaultSearchField()
+		}
+		if f != "" {
+			if fs == nil {
+				fs = make(FieldSet)
+			}
+			fs[f] = struct{}{}
+		}
+	case *QueryStringQuery:
+		var expandedQuery Query
+		expandedQuery, err = expandQuery(m, q)
+		if err == nil {
+			fs, err = ExtractFields(expandedQuery, m, fs)
+		}
+	case *BooleanQuery:
+		for _, subq := range []Query{q.Must, q.Should, q.MustNot} {
+			fs, err = ExtractFields(subq, m, fs)
+			if err != nil {
+				break
+			}
+		}
+	case *ConjunctionQuery:
+		for _, subq := range q.Conjuncts {
+			fs, err = ExtractFields(subq, m, fs)
+			if err != nil {
+				break
+			}
+		}
+	case *DisjunctionQuery:
+		for _, subq := range q.Disjuncts {
+			fs, err = ExtractFields(subq, m, fs)
+			if err != nil {
+				break
+			}
+		}
+	}
+	return fs, err
+}
+
+const (
+	FuzzyMatchType = iota
+	RegexpMatchType
+	PrefixMatchType
+)
+
+// ExtractSynonyms extracts synonyms from the query tree and returns a map of
+// field-term pairs to their synonyms. The input query tree is traversed and
+// for each term query, the synonyms are extracted from the synonym source
+// associated with the field. The synonyms are then added to the provided map.
+// The map is returned and may be nil if no synonyms were found.
+func ExtractSynonyms(ctx context.Context, m mapping.SynonymMapping, r index.ThesaurusReader,
+	query Query, rv search.FieldTermSynonymMap,
+) (search.FieldTermSynonymMap, error) {
+	if r == nil || m == nil || query == nil {
+		return rv, nil
+	}
+	var err error
+	resolveFieldAndSource := func(field string) (string, string) {
+		if field == "" {
+			field = m.DefaultSearchField()
+		}
+		return field, m.SynonymSourceForPath(field)
+	}
+	handleAnalyzer := func(analyzerName, field string) (analysis.Analyzer, error) {
+		if analyzerName == "" {
+			analyzerName = m.AnalyzerNameForPath(field)
+		}
+		analyzer := m.AnalyzerNamed(analyzerName)
+		if analyzer == nil {
+			return nil, fmt.Errorf("no analyzer named '%s' registered", analyzerName)
+		}
+		return analyzer, nil
+	}
+	switch q := query.(type) {
+	case *BooleanQuery:
+		rv, err = ExtractSynonyms(ctx, m, r, q.Must, rv)
+		if err != nil {
+			return nil, err
+		}
+		rv, err = ExtractSynonyms(ctx, m, r, q.Should, rv)
+		if err != nil {
+			return nil, err
+		}
+		rv, err = ExtractSynonyms(ctx, m, r, q.MustNot, rv)
+		if err != nil {
+			return nil, err
+		}
+	case *ConjunctionQuery:
+		for _, child := range q.Conjuncts {
+			rv, err = ExtractSynonyms(ctx, m, r, child, rv)
+			if err != nil {
+				return nil, err
+			}
+		}
+	case *DisjunctionQuery:
+		for _, child := range q.Disjuncts {
+			rv, err = ExtractSynonyms(ctx, m, r, child, rv)
+			if err != nil {
+				return nil, err
+			}
+		}
+	case *FuzzyQuery:
+		field, source := resolveFieldAndSource(q.FieldVal)
+		if source != "" {
+			fuzziness := q.Fuzziness
+			if q.autoFuzzy {
+				fuzziness = searcher.GetAutoFuzziness(q.Term)
+			}
+			rv, err = addSynonymsForTermWithMatchType(ctx, FuzzyMatchType, source, field, q.Term, fuzziness, q.Prefix, r, rv)
+			if err != nil {
+				return nil, err
+			}
+		}
+	case *MatchQuery, *MatchPhraseQuery:
+		var analyzerName, matchString, fieldVal string
+		var fuzziness, prefix int
+		var autoFuzzy bool
+		if mq, ok := q.(*MatchQuery); ok {
+			analyzerName, fieldVal, matchString, fuzziness, prefix, autoFuzzy = mq.Analyzer, mq.FieldVal, mq.Match, mq.Fuzziness, mq.Prefix, mq.autoFuzzy
+		} else if mpq, ok := q.(*MatchPhraseQuery); ok {
+			analyzerName, fieldVal, matchString, fuzziness, autoFuzzy = mpq.Analyzer, mpq.FieldVal, mpq.MatchPhrase, mpq.Fuzziness, mpq.autoFuzzy
+		}
+		field, source := resolveFieldAndSource(fieldVal)
+		if source != "" {
+			analyzer, err := handleAnalyzer(analyzerName, field)
+			if err != nil {
+				return nil, err
+			}
+			tokens := analyzer.Analyze([]byte(matchString))
+			for _, token := range tokens {
+				if autoFuzzy {
+					fuzziness = searcher.GetAutoFuzziness(string(token.Term))
+				}
+				rv, err = addSynonymsForTermWithMatchType(ctx, FuzzyMatchType, source, field, string(token.Term), fuzziness, prefix, r, rv)
+				if err != nil {
+					return nil, err
+				}
+			}
+		}
+	case *MultiPhraseQuery, *PhraseQuery:
+		var fieldVal string
+		var fuzziness int
+		var autoFuzzy bool
+		if mpq, ok := q.(*MultiPhraseQuery); ok {
+			fieldVal, fuzziness, autoFuzzy = mpq.FieldVal, mpq.Fuzziness, mpq.autoFuzzy
+		} else if pq, ok := q.(*PhraseQuery); ok {
+			fieldVal, fuzziness, autoFuzzy = pq.FieldVal, pq.Fuzziness, pq.autoFuzzy
+		}
+		field, source := resolveFieldAndSource(fieldVal)
+		if source != "" {
+			var terms []string
+			if mpq, ok := q.(*MultiPhraseQuery); ok {
+				for _, termGroup := range mpq.Terms {
+					terms = append(terms, termGroup...)
+				}
+			} else if pq, ok := q.(*PhraseQuery); ok {
+				terms = pq.Terms
+			}
+			for _, term := range terms {
+				if autoFuzzy {
+					fuzziness = searcher.GetAutoFuzziness(term)
+				}
+				rv, err = addSynonymsForTermWithMatchType(ctx, FuzzyMatchType, source, field, term, fuzziness, 0, r, rv)
+				if err != nil {
+					return nil, err
+				}
+			}
+		}
+	case *PrefixQuery:
+		field, source := resolveFieldAndSource(q.FieldVal)
+		if source != "" {
+			rv, err = addSynonymsForTermWithMatchType(ctx, PrefixMatchType, source, field, q.Prefix, 0, 0, r, rv)
+			if err != nil {
+				return nil, err
+			}
+		}
+	case *QueryStringQuery:
+		expanded, err := expandQuery(m, q)
+		if err != nil {
+			return nil, err
+		}
+		rv, err = ExtractSynonyms(ctx, m, r, expanded, rv)
+		if err != nil {
+			return nil, err
+		}
+	case *TermQuery:
+		field, source := resolveFieldAndSource(q.FieldVal)
+		if source != "" {
+			rv, err = addSynonymsForTerm(ctx, source, field, q.Term, r, rv)
+			if err != nil {
+				return nil, err
+			}
+		}
+	case *RegexpQuery:
+		field, source := resolveFieldAndSource(q.FieldVal)
+		if source != "" {
+			rv, err = addSynonymsForTermWithMatchType(ctx, RegexpMatchType, source, field, strings.TrimPrefix(q.Regexp, "^"), 0, 0, r, rv)
+			if err != nil {
+				return nil, err
+			}
+		}
+	case *WildcardQuery:
+		field, source := resolveFieldAndSource(q.FieldVal)
+		if source != "" {
+			rv, err = addSynonymsForTermWithMatchType(ctx, RegexpMatchType, source, field, wildcardRegexpReplacer.Replace(q.Wildcard), 0, 0, r, rv)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+	return rv, nil
+}
+
+// addFuzzySynonymsForTerm finds all terms that match the given term with the
+// given fuzziness and adds their synonyms to the provided map.
+func addSynonymsForTermWithMatchType(ctx context.Context, matchType int, src, field, term string, fuzziness, prefix int,
+	r index.ThesaurusReader, rv search.FieldTermSynonymMap,
+) (search.FieldTermSynonymMap, error) {
+	// Determine the terms based on the match type (fuzzy, prefix, or regexp)
+	var thesKeys index.ThesaurusKeys
+	var err error
+	var terms []string
+	switch matchType {
+	case FuzzyMatchType:
+		// Ensure valid fuzziness
+		if fuzziness == 0 {
+			rv, err = addSynonymsForTerm(ctx, src, field, term, r, rv)
+			if err != nil {
+				return nil, err
+			}
+			return rv, nil
+		}
+		if fuzziness > searcher.MaxFuzziness {
+			return nil, fmt.Errorf("fuzziness exceeds max (%d)", searcher.MaxFuzziness)
+		}
+		if fuzziness < 0 {
+			return nil, fmt.Errorf("invalid fuzziness, negative")
+		}
+		// Handle fuzzy match
+		prefixTerm := ""
+		for i, r := range term {
+			if i < prefix {
+				prefixTerm += string(r)
+			} else {
+				break
+			}
+		}
+		thesKeys, err = r.ThesaurusKeysFuzzy(src, term, fuzziness, prefixTerm)
+	case RegexpMatchType:
+		// Handle regexp match
+		thesKeys, err = r.ThesaurusKeysRegexp(src, term)
+	case PrefixMatchType:
+		// Handle prefix match
+		thesKeys, err = r.ThesaurusKeysPrefix(src, []byte(term))
+	default:
+		return nil, fmt.Errorf("invalid match type: %d", matchType)
+	}
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		if cerr := thesKeys.Close(); cerr != nil && err == nil {
+			err = cerr
+		}
+	}()
+	// Collect the matching terms
+	terms = []string{}
+	tfd, err := thesKeys.Next()
+	for err == nil && tfd != nil {
+		terms = append(terms, tfd.Term)
+		tfd, err = thesKeys.Next()
+	}
+	if err != nil {
+		return nil, err
+	}
+	for _, synTerm := range terms {
+		rv, err = addSynonymsForTerm(ctx, src, field, synTerm, r, rv)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return rv, nil
+}
+
+func addSynonymsForTerm(ctx context.Context, src, field, term string,
+	r index.ThesaurusReader, rv search.FieldTermSynonymMap,
+) (search.FieldTermSynonymMap, error) {
+	termReader, err := r.ThesaurusTermReader(ctx, src, []byte(term))
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		if cerr := termReader.Close(); cerr != nil && err == nil {
+			err = cerr
+		}
+	}()
+	var synonyms []string
+	synonym, err := termReader.Next()
+	for err == nil && synonym != "" {
+		synonyms = append(synonyms, synonym)
+		synonym, err = termReader.Next()
+	}
+	if err != nil {
+		return nil, err
+	}
+	if len(synonyms) > 0 {
+		if rv == nil {
+			rv = make(search.FieldTermSynonymMap)
+		}
+		if _, exists := rv[field]; !exists {
+			rv[field] = make(map[string][]string)
+		}
+		rv[field][term] = synonyms
+	}
+	return rv, nil
+}

search/query/query_string.go

@@ -0,0 +1,69 @@
+//  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 (
+	"context"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+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) Parse() (Query, error) {
+	return parseQuerySyntax(q.Query)
+}
+
+func (q *QueryStringQuery) Searcher(ctx context.Context, 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(ctx, 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
+}

search/query/query_string.y

@@ -0,0 +1,338 @@
+%{
+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>                fieldName
+%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
+}
+|
+fieldName 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
+}
+|
+fieldName 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
+}
+|
+fieldName 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
+}
+|
+fieldName tCOLON tPHRASE {
+	field := $1
+	phrase := $3
+	logDebugGrammar("FIELD - %s PHRASE - %s", field, phrase)
+	q := NewMatchPhraseQuery(phrase)
+	q.SetField(field)
+	$$ = q
+}
+|
+fieldName 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
+}
+|
+fieldName 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
+}
+|
+fieldName 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
+}
+|
+fieldName 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
+}
+|
+fieldName 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
+}
+|
+fieldName 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
+}
+|
+fieldName 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
+}
+|
+fieldName 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
+};
+
+fieldName:
+tPHRASE {
+    $$ = $1
+}
+|
+tSTRING {
+    $$ = $1
+};

search/query/query_string.y.go

@@ -0,0 +1,833 @@
+// Code generated by goyacc -o query_string.y.go query_string.y. DO NOT EDIT.
+
+//line query_string.y:2
+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,
+	-1, 9,
+	8, 29,
+	-2, 8,
+	-1, 12,
+	8, 28,
+	-2, 12,
+}
+
+const yyPrivate = 57344
+
+const yyLast = 43
+
+var yyAct = [...]int{
+	18, 17, 19, 24, 23, 15, 31, 22, 20, 21,
+	30, 27, 23, 23, 3, 22, 22, 14, 29, 26,
+	16, 25, 28, 35, 33, 23, 23, 32, 22, 22,
+	34, 9, 12, 1, 5, 6, 2, 11, 4, 13,
+	7, 8, 10,
+}
+
+var yyPact = [...]int{
+	28, -1000, -1000, 28, 27, -1000, -1000, -1000, 8, -9,
+	12, -1000, -1000, -1000, -1000, -1000, -3, -11, -1000, -1000,
+	6, 5, -1000, -4, -1000, -1000, 19, -1000, -1000, 18,
+	-1000, -1000, -1000, -1000, -1000, -1000,
+}
+
+var yyPgo = [...]int{
+	0, 0, 42, 41, 39, 38, 33, 36, 14,
+}
+
+var yyR1 = [...]int{
+	0, 6, 7, 7, 8, 5, 5, 5, 3, 3,
+	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+	3, 3, 3, 3, 4, 4, 1, 1, 2, 2,
+}
+
+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, 1, 1,
+}
+
+var yyChk = [...]int{
+	-1000, -6, -7, -8, -5, 6, 7, -7, -3, 4,
+	-2, 10, 5, -4, 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, -2,
+	0, 11, -2, 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:41
+		{
+			logDebugGrammar("INPUT")
+		}
+	case 2:
+		yyDollar = yyS[yypt-2 : yypt+1]
+//line query_string.y:46
+		{
+			logDebugGrammar("SEARCH PARTS")
+		}
+	case 3:
+		yyDollar = yyS[yypt-1 : yypt+1]
+//line query_string.y:50
+		{
+			logDebugGrammar("SEARCH PART")
+		}
+	case 4:
+		yyDollar = yyS[yypt-3 : yypt+1]
+//line query_string.y:55
+		{
+			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:74
+		{
+			yyVAL.n = queryShould
+		}
+	case 6:
+		yyDollar = yyS[yypt-1 : yypt+1]
+//line query_string.y:78
+		{
+			logDebugGrammar("PLUS")
+			yyVAL.n = queryMust
+		}
+	case 7:
+		yyDollar = yyS[yypt-1 : yypt+1]
+//line query_string.y:83
+		{
+			logDebugGrammar("MINUS")
+			yyVAL.n = queryMustNot
+		}
+	case 8:
+		yyDollar = yyS[yypt-1 : yypt+1]
+//line query_string.y:89
+		{
+			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:103
+		{
+			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:115
+		{
+			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:129
+		{
+			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:144
+		{
+			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:151
+		{
+			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:167
+		{
+			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:185
+		{
+			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:194
+		{
+			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:207
+		{
+			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:220
+		{
+			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:233
+		{
+			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:246
+		{
+			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:261
+		{
+			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:276
+		{
+			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:291
+		{
+			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:307
+		{
+			yyVAL.pf = nil
+		}
+	case 25:
+		yyDollar = yyS[yypt-1 : yypt+1]
+//line query_string.y:311
+		{
+			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:323
+		{
+			yyVAL.s = yyDollar[1].s
+		}
+	case 27:
+		yyDollar = yyS[yypt-2 : yypt+1]
+//line query_string.y:327
+		{
+			yyVAL.s = "-" + yyDollar[2].s
+		}
+	case 28:
+		yyDollar = yyS[yypt-1 : yypt+1]
+//line query_string.y:332
+		{
+			yyVAL.s = yyDollar[1].s
+		}
+	case 29:
+		yyDollar = yyS[yypt-1 : yypt+1]
+//line query_string.y:336
+		{
+			yyVAL.s = yyDollar[1].s
+		}
+	}
+	goto yystack /* stack new state and value */
+}

search/query/query_string_lex.go

@@ -0,0 +1,329 @@
+//  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) {
+	// end on non-escaped space, colon, tilde, boost (or eof)
+	if eof || (!l.inEscape && (next == ' ' || next == ':' || next == '^' || next == '~')) {
+		// end number
+		l.nextTokenType = tNUMBER
+		l.nextToken = &yySymType{
+			s: l.buf,
+		}
+		logDebugTokens("NUMBER - '%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
+		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.seenDot = true
+		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-escaped 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...)
+	}
+}

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)
+}

search/query/query_string_parser_test.go

@@ -0,0 +1,954 @@
+//  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 (
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+)
+
+func TestQuerySyntaxParserValid(t *testing.T) {
+	thirtyThreePointOh := 33.0
+	twoPointOh := 2.0
+	fivePointOh := 5.0
+	minusFivePointOh := -5.0
+	theTruth := true
+	theFalsehood := false
+	theDate, err := time.Parse(time.RFC3339, "2006-01-02T15:04:05Z")
+	if err != nil {
+		t.Fatal(err)
+	}
+	tests := []struct {
+		input   string
+		result  Query
+		mapping mapping.IndexMapping
+	}{
+		{
+			input:   "test",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					NewMatchQuery("test"),
+				},
+				nil),
+		},
+		{
+			input:   "127.0.0.1",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					NewMatchQuery("127.0.0.1"),
+				},
+				nil),
+		},
+		{
+			input:   `"test phrase 1"`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					NewMatchPhraseQuery("test phrase 1"),
+				},
+				nil),
+		},
+		{
+			input:   "field:test",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("test")
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		// - is allowed inside a term, just not the start
+		{
+			input:   "field:t-est",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("t-est")
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		// + is allowed inside a term, just not the start
+		{
+			input:   "field:t+est",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("t+est")
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		// > is allowed inside a term, just not the start
+		{
+			input:   "field:t>est",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("t>est")
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		// < is allowed inside a term, just not the start
+		{
+			input:   "field:t<est",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("t<est")
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		// = is allowed inside a term, just not the start
+		{
+			input:   "field:t=est",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("t=est")
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   "+field1:test1",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("test1")
+						q.SetField("field1")
+						return q
+					}(),
+				},
+				nil,
+				nil),
+		},
+		{
+			input:   "-field2:test2",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("test2")
+						q.SetField("field2")
+						return q
+					}(),
+				}),
+		},
+		{
+			input:   `field3:"test phrase 2"`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchPhraseQuery("test phrase 2")
+						q.SetField("field3")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   `+field4:"test phrase 1"`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				[]Query{
+					func() Query {
+						q := NewMatchPhraseQuery("test phrase 1")
+						q.SetField("field4")
+						return q
+					}(),
+				},
+				nil,
+				nil),
+		},
+		{
+			input:   `-field5:"test phrase 2"`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchPhraseQuery("test phrase 2")
+						q.SetField("field5")
+						return q
+					}(),
+				}),
+		},
+		{
+			input:   `+field6:test3 -field7:test4 field8:test5`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("test3")
+						q.SetField("field6")
+						return q
+					}(),
+				},
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("test5")
+						q.SetField("field8")
+						return q
+					}(),
+				},
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("test4")
+						q.SetField("field7")
+						return q
+					}(),
+				}),
+		},
+		{
+			input:   "test^3",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("test")
+						q.SetBoost(3.0)
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   "test^3 other^6",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("test")
+						q.SetBoost(3.0)
+						return q
+					}(),
+					func() Query {
+						q := NewMatchQuery("other")
+						q.SetBoost(6.0)
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   "33",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						qo := NewDisjunctionQuery(
+							[]Query{
+								NewMatchQuery("33"),
+								NewNumericRangeInclusiveQuery(&thirtyThreePointOh, &thirtyThreePointOh, &theTruth, &theTruth),
+							})
+						qo.queryStringMode = true
+						return qo
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   "field:33",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						qo := NewDisjunctionQuery(
+							[]Query{
+								func() Query {
+									q := NewMatchQuery("33")
+									q.SetField("field")
+									return q
+								}(),
+								func() Query {
+									q := NewNumericRangeInclusiveQuery(&thirtyThreePointOh, &thirtyThreePointOh, &theTruth, &theTruth)
+									q.SetField("field")
+									return q
+								}(),
+							})
+						qo.queryStringMode = true
+						return qo
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   "cat-dog",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					NewMatchQuery("cat-dog"),
+				},
+				nil),
+		},
+		{
+			input:   "watex~",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("watex")
+						q.SetFuzziness(1)
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   "watex~2",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("watex")
+						q.SetFuzziness(2)
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   "watex~ 2",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("watex")
+						q.SetFuzziness(1)
+						return q
+					}(),
+					func() Query {
+						qo := NewDisjunctionQuery(
+							[]Query{
+								NewMatchQuery("2"),
+								NewNumericRangeInclusiveQuery(&twoPointOh, &twoPointOh, &theTruth, &theTruth),
+							})
+						qo.queryStringMode = true
+						return qo
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   "field:watex~",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("watex")
+						q.SetFuzziness(1)
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   "field:watex~2",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("watex")
+						q.SetFuzziness(2)
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   `field:555c3bb06f7a127cda000005`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("555c3bb06f7a127cda000005")
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   `field:>5`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewNumericRangeInclusiveQuery(&fivePointOh, nil, &theFalsehood, nil)
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   `field:>=5`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewNumericRangeInclusiveQuery(&fivePointOh, nil, &theTruth, nil)
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   `field:<5`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewNumericRangeInclusiveQuery(nil, &fivePointOh, nil, &theFalsehood)
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   `field:<=5`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewNumericRangeInclusiveQuery(nil, &fivePointOh, nil, &theTruth)
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		// new range tests with negative number
+		{
+			input:   "field:-5",
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						qo := NewDisjunctionQuery(
+							[]Query{
+								func() Query {
+									q := NewMatchQuery("-5")
+									q.SetField("field")
+									return q
+								}(),
+								func() Query {
+									q := NewNumericRangeInclusiveQuery(&minusFivePointOh, &minusFivePointOh, &theTruth, &theTruth)
+									q.SetField("field")
+									return q
+								}(),
+							})
+						qo.queryStringMode = true
+						return qo
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   `field:>-5`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewNumericRangeInclusiveQuery(&minusFivePointOh, nil, &theFalsehood, nil)
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   `field:>=-5`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewNumericRangeInclusiveQuery(&minusFivePointOh, nil, &theTruth, nil)
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   `field:<-5`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewNumericRangeInclusiveQuery(nil, &minusFivePointOh, nil, &theFalsehood)
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   `field:<=-5`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewNumericRangeInclusiveQuery(nil, &minusFivePointOh, nil, &theTruth)
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   `field:>"2006-01-02T15:04:05Z"`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewDateRangeInclusiveQuery(theDate, time.Time{}, &theFalsehood, nil)
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   `field:>="2006-01-02T15:04:05Z"`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewDateRangeInclusiveQuery(theDate, time.Time{}, &theTruth, nil)
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   `field:<"2006-01-02T15:04:05Z"`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewDateRangeInclusiveQuery(time.Time{}, theDate, nil, &theFalsehood)
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   `field:<="2006-01-02T15:04:05Z"`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewDateRangeInclusiveQuery(time.Time{}, theDate, nil, &theTruth)
+						q.SetField("field")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   `/mar.*ty/`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					NewRegexpQuery("mar.*ty"),
+				},
+				nil),
+		},
+		{
+			input:   `name:/mar.*ty/`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewRegexpQuery("mar.*ty")
+						q.SetField("name")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   `mart*`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					NewWildcardQuery("mart*"),
+				},
+				nil),
+		},
+		{
+			input:   `name:mart*`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewWildcardQuery("mart*")
+						q.SetField("name")
+						return q
+					}(),
+				},
+				nil),
+		},
+
+		// tests for escaping
+
+		// escape : as field delimeter
+		{
+			input:   `name\:marty`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					NewMatchQuery("name:marty"),
+				},
+				nil),
+		},
+		// first colon delimiter, second escaped
+		{
+			input:   `name:marty\:couchbase`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("marty:couchbase")
+						q.SetField("name")
+						return q
+					}(),
+				},
+				nil),
+		},
+		// escape space, single arguemnt to match query
+		{
+			input:   `marty\ couchbase`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					NewMatchQuery("marty couchbase"),
+				},
+				nil),
+		},
+		// escape leading plus, not a must clause
+		{
+			input:   `\+marty`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					NewMatchQuery("+marty"),
+				},
+				nil),
+		},
+		// escape leading minus, not a must not clause
+		{
+			input:   `\-marty`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					NewMatchQuery("-marty"),
+				},
+				nil),
+		},
+		// escape quote inside of phrase
+		{
+			input:   `"what does \"quote\" mean"`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					NewMatchPhraseQuery(`what does "quote" mean`),
+				},
+				nil),
+		},
+		// escaping an unsupported character retains backslash
+		{
+			input:   `can\ i\ escap\e`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					NewMatchQuery(`can i escap\e`),
+				},
+				nil),
+		},
+		// leading spaces
+		{
+			input:   `   what`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					NewMatchQuery(`what`),
+				},
+				nil),
+		},
+		// no boost value defaults to 1
+		{
+			input:   `term^`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery(`term`)
+						q.SetBoost(1.0)
+						return q
+					}(),
+				},
+				nil),
+		},
+		// weird lexer cases, something that starts like a number
+		// but contains escape and ends up as string
+		{
+			input:   `3.0\:`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					NewMatchQuery(`3.0:`),
+				},
+				nil),
+		},
+		{
+			input:   `3.0\a`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					NewMatchQuery(`3.0\a`),
+				},
+				nil),
+		},
+
+		// field names as phrases
+		{
+			input:   `"fie ld":test`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchQuery("test")
+						q.SetField("fie ld")
+						return q
+					}(),
+				},
+				nil),
+		},
+		{
+			input:   `"fie ld":"test"`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewMatchPhraseQuery("test")
+						q.SetField("fie ld")
+						return q
+					}(),
+				},
+				nil),
+		},
+		// exact match number with boost
+		{
+			input:   `age:65^10`,
+			mapping: mapping.NewIndexMapping(),
+			result: NewBooleanQueryForQueryString(
+				nil,
+				[]Query{
+					func() Query {
+						q := NewDisjunctionQuery([]Query{
+							func() Query {
+								mq := NewMatchQuery("65")
+								mq.SetField("age")
+								return mq
+							}(),
+							func() Query {
+								val := float64(65)
+								inclusive := true
+								nq := NewNumericRangeInclusiveQuery(&val, &val, &inclusive, &inclusive)
+								nq.SetField("age")
+								return nq
+							}(),
+						})
+						q.SetBoost(10)
+						q.queryStringMode = true
+						return q
+					}(),
+				},
+				nil),
+		},
+	}
+
+	// turn on lexer debugging
+	// debugLexer = true
+	// debugParser = true
+	// logger = log.New(os.Stderr, "bleve ", log.LstdFlags)
+
+	for _, test := range tests {
+
+		q, err := parseQuerySyntax(test.input)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(q, test.result) {
+			t.Errorf("Expected %#v, got %#v: for %s", test.result, q, test.input)
+		}
+	}
+}
+
+func TestQuerySyntaxParserInvalid(t *testing.T) {
+	tests := []struct {
+		input string
+	}{
+		{"^"},
+		{"^5"},
+		{"field:-text"},
+		{"field:+text"},
+		{"field:>text"},
+		{"field:>=text"},
+		{"field:<text"},
+		{"field:<=text"},
+		{"field:~text"},
+		{"field:^text"},
+		{"field::text"},
+		{`"this is the time`},
+		{`cat^3\:`},
+		{`cat^3\0`},
+		{`cat~3\:`},
+		{`cat~3\0`},
+		{`99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999`},
+		{`field:99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999`},
+		{`field:>99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999`},
+		{`field:>=99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999`},
+		{`field:<99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999`},
+		{`field:<=99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999`},
+	}
+
+	// turn on lexer debugging
+	// debugLexer = true
+	// logger = log.New(os.Stderr, "bleve", log.LstdFlags)
+
+	for _, test := range tests {
+		_, err := parseQuerySyntax(test.input)
+		if err == nil {
+			t.Errorf("expected error, got nil for `%s`", test.input)
+		}
+	}
+}
+
+func BenchmarkLexer(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		var tokenTypes []int
+		var tokens []yySymType
+		r := strings.NewReader(`+field4:"test phrase 1"`)
+		l := newQueryStringLex(r)
+		var lval yySymType
+		rv := l.Lex(&lval)
+
+		for rv > 0 {
+			tokenTypes = append(tokenTypes, rv)
+			tokens = append(tokens, lval)
+
+			// use the slice to silence the compiler warning
+			_ = tokenTypes
+			_ = tokens
+
+			lval.s = ""
+			lval.n = 0
+			rv = l.Lex(&lval)
+		}
+	}
+}

search/query/regexp.go

@@ -0,0 +1,79 @@
+//  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 (
+	"context"
+	"strings"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+type RegexpQuery struct {
+	Regexp   string `json:"regexp"`
+	FieldVal string `json:"field,omitempty"`
+	BoostVal *Boost `json:"boost,omitempty"`
+}
+
+// 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(ctx context.Context, i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+
+	// require that pattern NOT be anchored to start and end of term.
+	// do not attempt to remove trailing $, its presence is not
+	// known to interfere with LiteralPrefix() the way ^ does
+	// and removing $ introduces possible ambiguities with escaped \$, \\$, etc
+	actualRegexp := q.Regexp
+	actualRegexp = strings.TrimPrefix(actualRegexp, "^") // remove leading ^ if it exists
+
+	return searcher.NewRegexpStringSearcher(ctx, i, actualRegexp, field, q.BoostVal.Value(), options)
+}
+
+func (q *RegexpQuery) Validate() error {
+	return nil // real validation delayed until searcher constructor
+}

search/query/term.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 (
+	"context"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+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(ctx context.Context, i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+	return searcher.NewTermSearcher(ctx, i, q.Term, field, q.BoostVal.Value(), options)
+}

search/query/term_range.go

@@ -0,0 +1,96 @@
+//  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 (
+	"context"
+	"fmt"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+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(ctx context.Context, 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(ctx, 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
+}

search/query/wildcard.go

@@ -0,0 +1,94 @@
+//  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 (
+	"context"
+	"strings"
+
+	"github.com/blevesearch/bleve/v2/mapping"
+	"github.com/blevesearch/bleve/v2/search"
+	"github.com/blevesearch/bleve/v2/search/searcher"
+	index "github.com/blevesearch/bleve_index_api"
+)
+
+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"`
+}
+
+// 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(ctx context.Context, i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error) {
+	field := q.FieldVal
+	if q.FieldVal == "" {
+		field = m.DefaultSearchField()
+	}
+
+	regexpString := wildcardRegexpReplacer.Replace(q.Wildcard)
+
+	return searcher.NewRegexpStringSearcher(ctx, i, regexpString, field,
+		q.BoostVal.Value(), options)
+}
+
+func (q *WildcardQuery) Validate() error {
+	return nil // real validation delayed until searcher constructor
+}