initial commit

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

@@ -0,0 +1,26 @@
+//  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 search
+
+import (
+	"time"
+
+	"golang.org/x/net/context"
+)
+
+type Collector interface {
+	Collect(ctx context.Context, searcher Searcher) error
+	Results() DocumentMatchCollection
+	Total() uint64
+	MaxScore() float64
+	Took() time.Duration
+	SetFacetsBuilder(facetsBuilder *FacetsBuilder)
+	FacetResults() FacetResults
+}

vendor/github.com/blevesearch/bleve/search/collectors/collector_top_score.go

@@ -0,0 +1,149 @@
+//  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 collectors
+
+import (
+	"container/list"
+	"time"
+
+	"golang.org/x/net/context"
+
+	"github.com/blevesearch/bleve/search"
+)
+
+type TopScoreCollector struct {
+	k             int
+	skip          int
+	results       *list.List
+	took          time.Duration
+	maxScore      float64
+	total         uint64
+	facetsBuilder *search.FacetsBuilder
+}
+
+func NewTopScorerCollector(k int) *TopScoreCollector {
+	return &TopScoreCollector{
+		k:       k,
+		skip:    0,
+		results: list.New(),
+	}
+}
+
+func NewTopScorerSkipCollector(k, skip int) *TopScoreCollector {
+	return &TopScoreCollector{
+		k:       k,
+		skip:    skip,
+		results: list.New(),
+	}
+}
+
+func (tksc *TopScoreCollector) Total() uint64 {
+	return tksc.total
+}
+
+func (tksc *TopScoreCollector) MaxScore() float64 {
+	return tksc.maxScore
+}
+
+func (tksc *TopScoreCollector) Took() time.Duration {
+	return tksc.took
+}
+
+func (tksc *TopScoreCollector) Collect(ctx context.Context, searcher search.Searcher) error {
+	startTime := time.Now()
+	var err error
+	var next *search.DocumentMatch
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
+		next, err = searcher.Next()
+	}
+	for err == nil && next != nil {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		default:
+			tksc.collectSingle(next)
+			if tksc.facetsBuilder != nil {
+				err = tksc.facetsBuilder.Update(next)
+				if err != nil {
+					break
+				}
+			}
+			next, err = searcher.Next()
+		}
+	}
+	// compute search duration
+	tksc.took = time.Since(startTime)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (tksc *TopScoreCollector) collectSingle(dm *search.DocumentMatch) {
+	// increment total hits
+	tksc.total++
+
+	// update max score
+	if dm.Score > tksc.maxScore {
+		tksc.maxScore = dm.Score
+	}
+
+	for e := tksc.results.Front(); e != nil; e = e.Next() {
+		curr := e.Value.(*search.DocumentMatch)
+		if dm.Score < curr.Score {
+
+			tksc.results.InsertBefore(dm, e)
+			// if we just made the list too long
+			if tksc.results.Len() > (tksc.k + tksc.skip) {
+				// remove the head
+				tksc.results.Remove(tksc.results.Front())
+			}
+			return
+		}
+	}
+	// if we got to the end, we still have to add it
+	tksc.results.PushBack(dm)
+	if tksc.results.Len() > (tksc.k + tksc.skip) {
+		// remove the head
+		tksc.results.Remove(tksc.results.Front())
+	}
+}
+
+func (tksc *TopScoreCollector) Results() search.DocumentMatchCollection {
+	if tksc.results.Len()-tksc.skip > 0 {
+		rv := make(search.DocumentMatchCollection, tksc.results.Len()-tksc.skip)
+		i := 0
+		skipped := 0
+		for e := tksc.results.Back(); e != nil; e = e.Prev() {
+			if skipped < tksc.skip {
+				skipped++
+				continue
+			}
+			rv[i] = e.Value.(*search.DocumentMatch)
+			i++
+		}
+		return rv
+	}
+	return search.DocumentMatchCollection{}
+}
+
+func (tksc *TopScoreCollector) SetFacetsBuilder(facetsBuilder *search.FacetsBuilder) {
+	tksc.facetsBuilder = facetsBuilder
+}
+
+func (tksc *TopScoreCollector) FacetResults() search.FacetResults {
+	if tksc.facetsBuilder != nil {
+		return tksc.facetsBuilder.Results()
+	}
+	return search.FacetResults{}
+}

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

@@ -0,0 +1,29 @@
+//  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 search
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type Explanation struct {
+	Value    float64        `json:"value"`
+	Message  string         `json:"message"`
+	Children []*Explanation `json:"children,omitempty"`
+}
+
+func (expl *Explanation) String() string {
+	js, err := json.MarshalIndent(expl, "", "  ")
+	if err != nil {
+		return fmt.Sprintf("error serializing explanation to json: %v", err)
+	}
+	return string(js)
+}

vendor/github.com/blevesearch/bleve/search/facets/facet_builder_datetime.go

@@ -0,0 +1,126 @@
+//  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 facets
+
+import (
+	"sort"
+	"time"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/numeric_util"
+	"github.com/blevesearch/bleve/search"
+)
+
+type dateTimeRange struct {
+	start time.Time
+	end   time.Time
+}
+
+type DateTimeFacetBuilder struct {
+	size       int
+	field      string
+	termsCount map[string]int
+	total      int
+	missing    int
+	ranges     map[string]*dateTimeRange
+}
+
+func NewDateTimeFacetBuilder(field string, size int) *DateTimeFacetBuilder {
+	return &DateTimeFacetBuilder{
+		size:       size,
+		field:      field,
+		termsCount: make(map[string]int),
+		ranges:     make(map[string]*dateTimeRange, 0),
+	}
+}
+
+func (fb *DateTimeFacetBuilder) AddRange(name string, start, end time.Time) {
+	r := dateTimeRange{
+		start: start,
+		end:   end,
+	}
+	fb.ranges[name] = &r
+}
+
+func (fb *DateTimeFacetBuilder) Update(ft index.FieldTerms) {
+	terms, ok := ft[fb.field]
+	if ok {
+		for _, term := range terms {
+			// only consider the values which are shifted 0
+			prefixCoded := numeric_util.PrefixCoded(term)
+			shift, err := prefixCoded.Shift()
+			if err == nil && shift == 0 {
+				i64, err := prefixCoded.Int64()
+				if err == nil {
+					t := time.Unix(0, i64)
+
+					// look at each of the ranges for a match
+					for rangeName, r := range fb.ranges {
+
+						if (r.start.IsZero() || t.After(r.start) || t.Equal(r.start)) && (r.end.IsZero() || t.Before(r.end)) {
+
+							existingCount, existed := fb.termsCount[rangeName]
+							if existed {
+								fb.termsCount[rangeName] = existingCount + 1
+							} else {
+								fb.termsCount[rangeName] = 1
+							}
+							fb.total++
+						}
+					}
+				}
+			}
+		}
+	} else {
+		fb.missing++
+	}
+}
+
+func (fb *DateTimeFacetBuilder) Result() *search.FacetResult {
+	rv := search.FacetResult{
+		Field:   fb.field,
+		Total:   fb.total,
+		Missing: fb.missing,
+	}
+
+	rv.DateRanges = make([]*search.DateRangeFacet, 0, len(fb.termsCount))
+
+	for term, count := range fb.termsCount {
+		dateRange := fb.ranges[term]
+		tf := &search.DateRangeFacet{
+			Name:  term,
+			Count: count,
+		}
+		if !dateRange.start.IsZero() {
+			start := dateRange.start.Format(time.RFC3339Nano)
+			tf.Start = &start
+		}
+		if !dateRange.end.IsZero() {
+			end := dateRange.end.Format(time.RFC3339Nano)
+			tf.End = &end
+		}
+		rv.DateRanges = append(rv.DateRanges, tf)
+	}
+
+	sort.Sort(rv.DateRanges)
+
+	// we now have the list of the top N facets
+	if fb.size < len(rv.DateRanges) {
+		rv.DateRanges = rv.DateRanges[:fb.size]
+	}
+
+	notOther := 0
+	for _, nr := range rv.DateRanges {
+		notOther += nr.Count
+	}
+	rv.Other = fb.total - notOther
+
+	return &rv
+}

vendor/github.com/blevesearch/bleve/search/facets/facet_builder_numeric.go

@@ -0,0 +1,120 @@
+//  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 facets
+
+import (
+	"sort"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/numeric_util"
+	"github.com/blevesearch/bleve/search"
+)
+
+type numericRange struct {
+	min *float64
+	max *float64
+}
+
+type NumericFacetBuilder struct {
+	size       int
+	field      string
+	termsCount map[string]int
+	total      int
+	missing    int
+	ranges     map[string]*numericRange
+}
+
+func NewNumericFacetBuilder(field string, size int) *NumericFacetBuilder {
+	return &NumericFacetBuilder{
+		size:       size,
+		field:      field,
+		termsCount: make(map[string]int),
+		ranges:     make(map[string]*numericRange, 0),
+	}
+}
+
+func (fb *NumericFacetBuilder) AddRange(name string, min, max *float64) {
+	r := numericRange{
+		min: min,
+		max: max,
+	}
+	fb.ranges[name] = &r
+}
+
+func (fb *NumericFacetBuilder) Update(ft index.FieldTerms) {
+	terms, ok := ft[fb.field]
+	if ok {
+		for _, term := range terms {
+			// only consider the values which are shifted 0
+			prefixCoded := numeric_util.PrefixCoded(term)
+			shift, err := prefixCoded.Shift()
+			if err == nil && shift == 0 {
+				i64, err := prefixCoded.Int64()
+				if err == nil {
+					f64 := numeric_util.Int64ToFloat64(i64)
+
+					// look at each of the ranges for a match
+					for rangeName, r := range fb.ranges {
+
+						if (r.min == nil || f64 >= *r.min) && (r.max == nil || f64 < *r.max) {
+
+							existingCount, existed := fb.termsCount[rangeName]
+							if existed {
+								fb.termsCount[rangeName] = existingCount + 1
+							} else {
+								fb.termsCount[rangeName] = 1
+							}
+							fb.total++
+						}
+					}
+				}
+			}
+		}
+	} else {
+		fb.missing++
+	}
+}
+
+func (fb *NumericFacetBuilder) Result() *search.FacetResult {
+	rv := search.FacetResult{
+		Field:   fb.field,
+		Total:   fb.total,
+		Missing: fb.missing,
+	}
+
+	rv.NumericRanges = make([]*search.NumericRangeFacet, 0, len(fb.termsCount))
+
+	for term, count := range fb.termsCount {
+		numericRange := fb.ranges[term]
+		tf := &search.NumericRangeFacet{
+			Name:  term,
+			Count: count,
+			Min:   numericRange.min,
+			Max:   numericRange.max,
+		}
+
+		rv.NumericRanges = append(rv.NumericRanges, tf)
+	}
+
+	sort.Sort(rv.NumericRanges)
+
+	// we now have the list of the top N facets
+	if fb.size < len(rv.NumericRanges) {
+		rv.NumericRanges = rv.NumericRanges[:fb.size]
+	}
+
+	notOther := 0
+	for _, nr := range rv.NumericRanges {
+		notOther += nr.Count
+	}
+	rv.Other = fb.total - notOther
+
+	return &rv
+}

vendor/github.com/blevesearch/bleve/search/facets/facet_builder_terms.go

@@ -0,0 +1,86 @@
+//  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 facets
+
+import (
+	"sort"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/search"
+)
+
+type TermsFacetBuilder struct {
+	size       int
+	field      string
+	termsCount map[string]int
+	total      int
+	missing    int
+}
+
+func NewTermsFacetBuilder(field string, size int) *TermsFacetBuilder {
+	return &TermsFacetBuilder{
+		size:       size,
+		field:      field,
+		termsCount: make(map[string]int),
+	}
+}
+
+func (fb *TermsFacetBuilder) Update(ft index.FieldTerms) {
+	terms, ok := ft[fb.field]
+	if ok {
+		for _, term := range terms {
+			existingCount, existed := fb.termsCount[term]
+			if existed {
+				fb.termsCount[term] = existingCount + 1
+			} else {
+				fb.termsCount[term] = 1
+			}
+			fb.total++
+		}
+	} else {
+		fb.missing++
+	}
+}
+
+func (fb *TermsFacetBuilder) Result() *search.FacetResult {
+	rv := search.FacetResult{
+		Field:   fb.field,
+		Total:   fb.total,
+		Missing: fb.missing,
+	}
+
+	rv.Terms = make([]*search.TermFacet, 0, len(fb.termsCount))
+
+	for term, count := range fb.termsCount {
+		tf := &search.TermFacet{
+			Term:  term,
+			Count: count,
+		}
+
+		rv.Terms = append(rv.Terms, tf)
+	}
+
+	sort.Sort(rv.Terms)
+
+	// we now have the list of the top N facets
+	trimTopN := fb.size
+	if trimTopN > len(rv.Terms) {
+		trimTopN = len(rv.Terms)
+	}
+	rv.Terms = rv.Terms[:trimTopN]
+
+	notOther := 0
+	for _, tf := range rv.Terms {
+		notOther += tf.Count
+	}
+	rv.Other = fb.total - notOther
+
+	return &rv
+}

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

@@ -0,0 +1,250 @@
+//  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 search
+
+import (
+	"sort"
+
+	"github.com/blevesearch/bleve/index"
+)
+
+type FacetBuilder interface {
+	Update(index.FieldTerms)
+	Result() *FacetResult
+}
+
+type FacetsBuilder struct {
+	indexReader index.IndexReader
+	facets      map[string]FacetBuilder
+}
+
+func NewFacetsBuilder(indexReader index.IndexReader) *FacetsBuilder {
+	return &FacetsBuilder{
+		indexReader: indexReader,
+		facets:      make(map[string]FacetBuilder, 0),
+	}
+}
+
+func (fb *FacetsBuilder) Add(name string, facetBuilder FacetBuilder) {
+	fb.facets[name] = facetBuilder
+}
+
+func (fb *FacetsBuilder) Update(docMatch *DocumentMatch) error {
+	fieldTerms, err := fb.indexReader.DocumentFieldTerms(docMatch.ID)
+	if err != nil {
+		return err
+	}
+	for _, facetBuilder := range fb.facets {
+		facetBuilder.Update(fieldTerms)
+	}
+	return nil
+}
+
+type TermFacet struct {
+	Term  string `json:"term"`
+	Count int    `json:"count"`
+}
+
+type TermFacets []*TermFacet
+
+func (tf TermFacets) Add(termFacet *TermFacet) TermFacets {
+	for _, existingTerm := range tf {
+		if termFacet.Term == existingTerm.Term {
+			existingTerm.Count += termFacet.Count
+			return tf
+		}
+	}
+	// if we got here it wasn't already in the existing terms
+	tf = append(tf, termFacet)
+	return tf
+}
+
+func (tf TermFacets) Len() int      { return len(tf) }
+func (tf TermFacets) Swap(i, j int) { tf[i], tf[j] = tf[j], tf[i] }
+func (tf TermFacets) Less(i, j int) bool {
+	if tf[i].Count == tf[j].Count {
+		return tf[i].Term < tf[j].Term
+	}
+	return tf[i].Count > tf[j].Count
+}
+
+type NumericRangeFacet struct {
+	Name  string   `json:"name"`
+	Min   *float64 `json:"min,omitempty"`
+	Max   *float64 `json:"max,omitempty"`
+	Count int      `json:"count"`
+}
+
+type NumericRangeFacets []*NumericRangeFacet
+
+func (nrf NumericRangeFacets) Add(numericRangeFacet *NumericRangeFacet) NumericRangeFacets {
+	for _, existingNr := range nrf {
+		if numericRangeFacet.Min == existingNr.Min && numericRangeFacet.Max == existingNr.Max {
+			existingNr.Count += numericRangeFacet.Count
+			return nrf
+		}
+	}
+	// if we got here it wasn't already in the existing terms
+	nrf = append(nrf, numericRangeFacet)
+	return nrf
+}
+
+func (nrf NumericRangeFacets) Len() int      { return len(nrf) }
+func (nrf NumericRangeFacets) Swap(i, j int) { nrf[i], nrf[j] = nrf[j], nrf[i] }
+func (nrf NumericRangeFacets) Less(i, j int) bool {
+	if nrf[i].Count == nrf[j].Count {
+		return nrf[i].Name < nrf[j].Name
+	}
+	return nrf[i].Count > nrf[j].Count
+}
+
+type DateRangeFacet struct {
+	Name  string  `json:"name"`
+	Start *string `json:"start,omitempty"`
+	End   *string `json:"end,omitempty"`
+	Count int     `json:"count"`
+}
+
+func (drf *DateRangeFacet) Same(other *DateRangeFacet) bool {
+	if drf.Start == nil && other.Start != nil {
+		return false
+	}
+	if drf.Start != nil && other.Start == nil {
+		return false
+	}
+	if drf.Start != nil && other.Start != nil && *drf.Start != *other.Start {
+		return false
+	}
+	if drf.End == nil && other.End != nil {
+		return false
+	}
+	if drf.End != nil && other.End == nil {
+		return false
+	}
+	if drf.End != nil && other.End != nil && *drf.End != *other.End {
+		return false
+	}
+
+	return true
+}
+
+type DateRangeFacets []*DateRangeFacet
+
+func (drf DateRangeFacets) Add(dateRangeFacet *DateRangeFacet) DateRangeFacets {
+	for _, existingDr := range drf {
+		if dateRangeFacet.Same(existingDr) {
+			existingDr.Count += dateRangeFacet.Count
+			return drf
+		}
+	}
+	// if we got here it wasn't already in the existing terms
+	drf = append(drf, dateRangeFacet)
+	return drf
+}
+
+func (drf DateRangeFacets) Len() int      { return len(drf) }
+func (drf DateRangeFacets) Swap(i, j int) { drf[i], drf[j] = drf[j], drf[i] }
+func (drf DateRangeFacets) Less(i, j int) bool {
+	if drf[i].Count == drf[j].Count {
+		return drf[i].Name < drf[j].Name
+	}
+	return drf[i].Count > drf[j].Count
+}
+
+type FacetResult struct {
+	Field         string             `json:"field"`
+	Total         int                `json:"total"`
+	Missing       int                `json:"missing"`
+	Other         int                `json:"other"`
+	Terms         TermFacets         `json:"terms,omitempty"`
+	NumericRanges NumericRangeFacets `json:"numeric_ranges,omitempty"`
+	DateRanges    DateRangeFacets    `json:"date_ranges,omitempty"`
+}
+
+func (fr *FacetResult) Merge(other *FacetResult) {
+	fr.Total += other.Total
+	fr.Missing += other.Missing
+	fr.Other += other.Other
+	if fr.Terms != nil && other.Terms != nil {
+		for _, term := range other.Terms {
+			fr.Terms = fr.Terms.Add(term)
+		}
+	}
+	if fr.NumericRanges != nil && other.NumericRanges != nil {
+		for _, nr := range other.NumericRanges {
+			fr.NumericRanges = fr.NumericRanges.Add(nr)
+		}
+	}
+	if fr.DateRanges != nil && other.DateRanges != nil {
+		for _, dr := range other.DateRanges {
+			fr.DateRanges = fr.DateRanges.Add(dr)
+		}
+	}
+}
+
+func (fr *FacetResult) Fixup(size int) {
+	if fr.Terms != nil {
+		sort.Sort(fr.Terms)
+		if len(fr.Terms) > size {
+			moveToOther := fr.Terms[size:]
+			for _, mto := range moveToOther {
+				fr.Other += mto.Count
+			}
+			fr.Terms = fr.Terms[0:size]
+		}
+	} else if fr.NumericRanges != nil {
+		sort.Sort(fr.NumericRanges)
+		if len(fr.NumericRanges) > size {
+			moveToOther := fr.NumericRanges[size:]
+			for _, mto := range moveToOther {
+				fr.Other += mto.Count
+			}
+			fr.NumericRanges = fr.NumericRanges[0:size]
+		}
+	} else if fr.DateRanges != nil {
+		sort.Sort(fr.DateRanges)
+		if len(fr.DateRanges) > size {
+			moveToOther := fr.DateRanges[size:]
+			for _, mto := range moveToOther {
+				fr.Other += mto.Count
+			}
+			fr.DateRanges = fr.DateRanges[0:size]
+		}
+	}
+}
+
+type FacetResults map[string]*FacetResult
+
+func (fr FacetResults) Merge(other FacetResults) {
+	for name, oFacetResult := range other {
+		facetResult, ok := fr[name]
+		if ok {
+			facetResult.Merge(oFacetResult)
+		} else {
+			fr[name] = oFacetResult
+		}
+	}
+}
+
+func (fr FacetResults) Fixup(name string, size int) {
+	facetResult, ok := fr[name]
+	if ok {
+		facetResult.Fixup(size)
+	}
+}
+
+func (fb *FacetsBuilder) Results() FacetResults {
+	fr := make(FacetResults)
+	for facetName, facetBuilder := range fb.facets {
+		facetResult := facetBuilder.Result()
+		fr[facetName] = facetResult
+	}
+	return fr
+}

vendor/github.com/blevesearch/bleve/search/highlight/fragment_formatters/html/fragment_formatter_html.go

@@ -0,0 +1,84 @@
+//  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 html
+
+import (
+	"github.com/blevesearch/bleve/registry"
+	"github.com/blevesearch/bleve/search/highlight"
+)
+
+const Name = "html"
+
+const defaultHTMLHighlightBefore = "<mark>"
+const defaultHTMLHighlightAfter = "</mark>"
+
+type FragmentFormatter struct {
+	before string
+	after  string
+}
+
+func NewFragmentFormatter(before, after string) *FragmentFormatter {
+	return &FragmentFormatter{
+		before: before,
+		after:  after,
+	}
+}
+
+func (a *FragmentFormatter) Format(f *highlight.Fragment, orderedTermLocations highlight.TermLocations) string {
+	rv := ""
+	curr := f.Start
+	for _, termLocation := range orderedTermLocations {
+		if termLocation == nil {
+			continue
+		}
+		// make sure the array positions match
+		if !highlight.SameArrayPositions(f.ArrayPositions, termLocation.ArrayPositions) {
+			continue
+		}
+		if termLocation.Start < curr {
+			continue
+		}
+		if termLocation.End > f.End {
+			break
+		}
+		// add the stuff before this location
+		rv += string(f.Orig[curr:termLocation.Start])
+		// add the color
+		rv += a.before
+		// add the term itself
+		rv += string(f.Orig[termLocation.Start:termLocation.End])
+		// reset the color
+		rv += a.after
+		// update current
+		curr = termLocation.End
+	}
+	// add any remaining text after the last token
+	rv += string(f.Orig[curr:f.End])
+
+	return rv
+}
+
+func Constructor(config map[string]interface{}, cache *registry.Cache) (highlight.FragmentFormatter, error) {
+	before := defaultHTMLHighlightBefore
+	beforeVal, ok := config["before"].(string)
+	if ok {
+		before = beforeVal
+	}
+	after := defaultHTMLHighlightAfter
+	afterVal, ok := config["after"].(string)
+	if ok {
+		after = afterVal
+	}
+	return NewFragmentFormatter(before, after), nil
+}
+
+func init() {
+	registry.RegisterFragmentFormatter(Name, Constructor)
+}

vendor/github.com/blevesearch/bleve/search/highlight/fragmenters/simple/fragmenter_simple.go

@@ -0,0 +1,138 @@
+//  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 simple
+
+import (
+	"unicode/utf8"
+
+	"github.com/blevesearch/bleve/registry"
+	"github.com/blevesearch/bleve/search/highlight"
+)
+
+const Name = "simple"
+
+const defaultFragmentSize = 200
+
+type Fragmenter struct {
+	fragmentSize int
+}
+
+func NewFragmenter(fragmentSize int) *Fragmenter {
+	return &Fragmenter{
+		fragmentSize: fragmentSize,
+	}
+}
+
+func (s *Fragmenter) Fragment(orig []byte, ot highlight.TermLocations) []*highlight.Fragment {
+	rv := make([]*highlight.Fragment, 0)
+
+	maxbegin := 0
+OUTER:
+	for currTermIndex, termLocation := range ot {
+		// start with this
+		// it should be the highest scoring fragment with this term first
+		start := termLocation.Start
+		end := start
+		used := 0
+		for end < len(orig) && used < s.fragmentSize {
+			r, size := utf8.DecodeRune(orig[end:])
+			if r == utf8.RuneError {
+				continue OUTER // bail
+			}
+			end += size
+			used += 1
+		}
+
+		// if we still have more characters available to us
+		// push back towards beginning
+		// without cross maxbegin
+		for start > 0 && used < s.fragmentSize {
+			r, size := utf8.DecodeLastRune(orig[0:start])
+			if r == utf8.RuneError {
+				continue OUTER // bail
+			}
+			if start-size >= maxbegin {
+				start -= size
+				used += 1
+			} else {
+				break
+			}
+		}
+
+		// however, we'd rather have the tokens centered more in the frag
+		// lets try to do that as best we can, without affecting the score
+		// find the end of the last term in this fragment
+		minend := end
+		for _, innerTermLocation := range ot[currTermIndex:] {
+			if innerTermLocation.End > end {
+				break
+			}
+			minend = innerTermLocation.End
+		}
+
+		// find the smaller of the two rooms to move
+		roomToMove := utf8.RuneCount(orig[minend:end])
+		roomToMoveStart := 0
+		if start >= maxbegin {
+			roomToMoveStart = utf8.RuneCount(orig[maxbegin:start])
+		}
+		if roomToMoveStart < roomToMove {
+			roomToMove = roomToMoveStart
+		}
+
+		offset := roomToMove / 2
+
+		for offset > 0 {
+			r, size := utf8.DecodeLastRune(orig[0:start])
+			if r == utf8.RuneError {
+				continue OUTER // bail
+			}
+			start -= size
+
+			r, size = utf8.DecodeLastRune(orig[0:end])
+			if r == utf8.RuneError {
+				continue OUTER // bail
+			}
+			end -= size
+			offset--
+		}
+
+		rv = append(rv, &highlight.Fragment{Orig: orig, Start: start - offset, End: end - offset})
+		// set maxbegin to the end of the current term location
+		// so that next one won't back up to include it
+		maxbegin = termLocation.End
+
+	}
+	if len(ot) == 0 {
+		// if there were no terms to highlight
+		// produce a single fragment from the beginning
+		start := 0
+		end := start + s.fragmentSize
+		if end > len(orig) {
+			end = len(orig)
+		}
+		rv = append(rv, &highlight.Fragment{Orig: orig, Start: start, End: end})
+	}
+
+	return rv
+}
+
+func Constructor(config map[string]interface{}, cache *registry.Cache) (highlight.Fragmenter, error) {
+	size := defaultFragmentSize
+	sizeVal, ok := config["size"].(float64)
+	if ok {
+		size = int(sizeVal)
+	}
+	return NewFragmenter(size), nil
+}
+
+func init() {
+	registry.RegisterFragmenter(Name, Constructor)
+}

vendor/github.com/blevesearch/bleve/search/highlight/highlighter.go

@@ -0,0 +1,59 @@
+//  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 highlight
+
+import (
+	"github.com/blevesearch/bleve/document"
+	"github.com/blevesearch/bleve/search"
+)
+
+type Fragment struct {
+	Orig           []byte
+	ArrayPositions []uint64
+	Start          int
+	End            int
+	Score          float64
+	Index          int // used by heap
+}
+
+func (f *Fragment) Overlaps(other *Fragment) bool {
+	if other.Start >= f.Start && other.Start < f.End {
+		return true
+	} else if f.Start >= other.Start && f.Start < other.End {
+		return true
+	}
+	return false
+}
+
+type Fragmenter interface {
+	Fragment([]byte, TermLocations) []*Fragment
+}
+
+type FragmentFormatter interface {
+	Format(f *Fragment, orderedTermLocations TermLocations) string
+}
+
+type FragmentScorer interface {
+	Score(f *Fragment) float64
+}
+
+type Highlighter interface {
+	Fragmenter() Fragmenter
+	SetFragmenter(Fragmenter)
+
+	FragmentFormatter() FragmentFormatter
+	SetFragmentFormatter(FragmentFormatter)
+
+	Separator() string
+	SetSeparator(string)
+
+	BestFragmentInField(*search.DocumentMatch, *document.Document, string) string
+	BestFragmentsInField(*search.DocumentMatch, *document.Document, string, int) []string
+}

vendor/github.com/blevesearch/bleve/search/highlight/highlighters/html/html.go

@@ -0,0 +1,45 @@
+//  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 html
+
+import (
+	"fmt"
+
+	"github.com/blevesearch/bleve/registry"
+	"github.com/blevesearch/bleve/search/highlight"
+	html_formatter "github.com/blevesearch/bleve/search/highlight/fragment_formatters/html"
+	simple_fragmenter "github.com/blevesearch/bleve/search/highlight/fragmenters/simple"
+	simple_highlighter "github.com/blevesearch/bleve/search/highlight/highlighters/simple"
+)
+
+const Name = "html"
+
+func Constructor(config map[string]interface{}, cache *registry.Cache) (highlight.Highlighter, error) {
+
+	fragmenter, err := cache.FragmenterNamed(simple_fragmenter.Name)
+	if err != nil {
+		return nil, fmt.Errorf("error building fragmenter: %v", err)
+	}
+
+	formatter, err := cache.FragmentFormatterNamed(html_formatter.Name)
+	if err != nil {
+		return nil, fmt.Errorf("error building fragment formatter: %v", err)
+	}
+
+	return simple_highlighter.NewHighlighter(
+			fragmenter,
+			formatter,
+			simple_highlighter.DefaultSeparator),
+		nil
+}
+
+func init() {
+	registry.RegisterHighlighter(Name, Constructor)
+}

vendor/github.com/blevesearch/bleve/search/highlight/highlighters/simple/fragment_scorer_simple.go

@@ -0,0 +1,44 @@
+//  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 simple
+
+import (
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/highlight"
+)
+
+// FragmentScorer will score fragments by how many
+// unique terms occur in the fragment with no regard for
+// any boost values used in the original query
+type FragmentScorer struct {
+	tlm search.TermLocationMap
+}
+
+func NewFragmentScorer(tlm search.TermLocationMap) *FragmentScorer {
+	return &FragmentScorer{
+		tlm: tlm,
+	}
+}
+
+func (s *FragmentScorer) Score(f *highlight.Fragment) {
+	score := 0.0
+OUTER:
+	for _, locations := range s.tlm {
+		for _, location := range locations {
+			if highlight.SameArrayPositions(f.ArrayPositions, location.ArrayPositions) && int(location.Start) >= f.Start && int(location.End) <= f.End {
+				score += 1.0
+				// once we find a term in the fragment
+				// don't care about additional matches
+				continue OUTER
+			}
+		}
+	}
+	f.Score = score
+}

vendor/github.com/blevesearch/bleve/search/highlight/highlighters/simple/highlighter_simple.go

@@ -0,0 +1,216 @@
+//  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 simple
+
+import (
+	"container/heap"
+	"fmt"
+
+	"github.com/blevesearch/bleve/document"
+	"github.com/blevesearch/bleve/registry"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/highlight"
+)
+
+const Name = "simple"
+const DefaultSeparator = "…"
+
+type Highlighter struct {
+	fragmenter highlight.Fragmenter
+	formatter  highlight.FragmentFormatter
+	sep        string
+}
+
+func NewHighlighter(fragmenter highlight.Fragmenter, formatter highlight.FragmentFormatter, separator string) *Highlighter {
+	return &Highlighter{
+		fragmenter: fragmenter,
+		formatter:  formatter,
+		sep:        separator,
+	}
+}
+
+func (s *Highlighter) Fragmenter() highlight.Fragmenter {
+	return s.fragmenter
+}
+
+func (s *Highlighter) SetFragmenter(f highlight.Fragmenter) {
+	s.fragmenter = f
+}
+
+func (s *Highlighter) FragmentFormatter() highlight.FragmentFormatter {
+	return s.formatter
+}
+
+func (s *Highlighter) SetFragmentFormatter(f highlight.FragmentFormatter) {
+	s.formatter = f
+}
+
+func (s *Highlighter) Separator() string {
+	return s.sep
+}
+
+func (s *Highlighter) SetSeparator(sep string) {
+	s.sep = sep
+}
+
+func (s *Highlighter) BestFragmentInField(dm *search.DocumentMatch, doc *document.Document, field string) string {
+	fragments := s.BestFragmentsInField(dm, doc, field, 1)
+	if len(fragments) > 0 {
+		return fragments[0]
+	}
+	return ""
+}
+
+func (s *Highlighter) BestFragmentsInField(dm *search.DocumentMatch, doc *document.Document, field string, num int) []string {
+	tlm := dm.Locations[field]
+	orderedTermLocations := highlight.OrderTermLocations(tlm)
+	scorer := NewFragmentScorer(tlm)
+
+	// score the fragments and put them into a priority queue ordered by score
+	fq := make(FragmentQueue, 0)
+	heap.Init(&fq)
+	for _, f := range doc.Fields {
+		if f.Name() == field {
+			_, ok := f.(*document.TextField)
+			if ok {
+				termLocationsSameArrayPosition := make(highlight.TermLocations, 0)
+				for _, otl := range orderedTermLocations {
+					if highlight.SameArrayPositions(f.ArrayPositions(), otl.ArrayPositions) {
+						termLocationsSameArrayPosition = append(termLocationsSameArrayPosition, otl)
+					}
+				}
+
+				fieldData := f.Value()
+				fragments := s.fragmenter.Fragment(fieldData, termLocationsSameArrayPosition)
+				for _, fragment := range fragments {
+					fragment.ArrayPositions = f.ArrayPositions()
+					scorer.Score(fragment)
+					heap.Push(&fq, fragment)
+				}
+			}
+		}
+	}
+
+	// now find the N best non-overlapping fragments
+	bestFragments := make([]*highlight.Fragment, 0)
+	if len(fq) > 0 {
+		candidate := heap.Pop(&fq)
+	OUTER:
+		for candidate != nil && len(bestFragments) < num {
+			// see if this overlaps with any of the best already identified
+			if len(bestFragments) > 0 {
+				for _, frag := range bestFragments {
+					if candidate.(*highlight.Fragment).Overlaps(frag) {
+						if len(fq) < 1 {
+							break OUTER
+						}
+						candidate = heap.Pop(&fq)
+						continue OUTER
+					}
+				}
+				bestFragments = append(bestFragments, candidate.(*highlight.Fragment))
+			} else {
+				bestFragments = append(bestFragments, candidate.(*highlight.Fragment))
+			}
+
+			if len(fq) < 1 {
+				break
+			}
+			candidate = heap.Pop(&fq)
+		}
+	}
+
+	// now that we have the best fragments, we can format them
+	orderedTermLocations.MergeOverlapping()
+	formattedFragments := make([]string, len(bestFragments))
+	for i, fragment := range bestFragments {
+		formattedFragments[i] = ""
+		if fragment.Start != 0 {
+			formattedFragments[i] += s.sep
+		}
+		formattedFragments[i] += s.formatter.Format(fragment, orderedTermLocations)
+		if fragment.End != len(fragment.Orig) {
+			formattedFragments[i] += s.sep
+		}
+	}
+
+	if dm.Fragments == nil {
+		dm.Fragments = make(search.FieldFragmentMap, 0)
+	}
+	if len(formattedFragments) > 0 {
+		dm.Fragments[field] = formattedFragments
+	}
+
+	return formattedFragments
+}
+
+// FragmentQueue implements heap.Interface and holds Items.
+type FragmentQueue []*highlight.Fragment
+
+func (fq FragmentQueue) Len() int { return len(fq) }
+
+func (fq FragmentQueue) Less(i, j int) bool {
+	// We want Pop to give us the highest, not lowest, priority so we use greater-than here.
+	return fq[i].Score > fq[j].Score
+}
+
+func (fq FragmentQueue) Swap(i, j int) {
+	fq[i], fq[j] = fq[j], fq[i]
+	fq[i].Index = i
+	fq[j].Index = j
+}
+
+func (fq *FragmentQueue) Push(x interface{}) {
+	n := len(*fq)
+	item := x.(*highlight.Fragment)
+	item.Index = n
+	*fq = append(*fq, item)
+}
+
+func (fq *FragmentQueue) Pop() interface{} {
+	old := *fq
+	n := len(old)
+	item := old[n-1]
+	item.Index = -1 // for safety
+	*fq = old[0 : n-1]
+	return item
+}
+
+func Constructor(config map[string]interface{}, cache *registry.Cache) (highlight.Highlighter, error) {
+	separator := DefaultSeparator
+	separatorVal, ok := config["separator"].(string)
+	if ok {
+		separator = separatorVal
+	}
+
+	fragmenterName, ok := config["fragmenter"].(string)
+	if !ok {
+		return nil, fmt.Errorf("must specify fragmenter")
+	}
+	fragmenter, err := cache.FragmenterNamed(fragmenterName)
+	if err != nil {
+		return nil, fmt.Errorf("error building fragmenter: %v", err)
+	}
+
+	formatterName, ok := config["formatter"].(string)
+	if !ok {
+		return nil, fmt.Errorf("must specify formatter")
+	}
+	formatter, err := cache.FragmentFormatterNamed(formatterName)
+	if err != nil {
+		return nil, fmt.Errorf("error building fragment formatter: %v", err)
+	}
+
+	return NewHighlighter(fragmenter, formatter, separator), nil
+}
+
+func init() {
+	registry.RegisterHighlighter(Name, Constructor)
+}

vendor/github.com/blevesearch/bleve/search/highlight/term_locations.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 highlight
+
+import (
+	"reflect"
+	"sort"
+
+	"github.com/blevesearch/bleve/search"
+)
+
+type TermLocation struct {
+	Term           string
+	ArrayPositions []float64
+	Pos            int
+	Start          int
+	End            int
+}
+
+func (tl *TermLocation) Overlaps(other *TermLocation) bool {
+	if reflect.DeepEqual(tl.ArrayPositions, other.ArrayPositions) {
+		if other.Start >= tl.Start && other.Start < tl.End {
+			return true
+		} else if tl.Start >= other.Start && tl.Start < other.End {
+			return true
+		}
+	}
+	return false
+}
+
+type TermLocations []*TermLocation
+
+func (t TermLocations) Len() int      { return len(t) }
+func (t TermLocations) Swap(i, j int) { t[i], t[j] = t[j], t[i] }
+func (t TermLocations) Less(i, j int) bool {
+
+	shortestArrayPositions := len(t[i].ArrayPositions)
+	if len(t[j].ArrayPositions) < shortestArrayPositions {
+		shortestArrayPositions = len(t[j].ArrayPositions)
+	}
+
+	// compare all the common array positions
+	for api := 0; api < shortestArrayPositions; api++ {
+		if t[i].ArrayPositions[api] < t[j].ArrayPositions[api] {
+			return true
+		}
+		if t[i].ArrayPositions[api] > t[j].ArrayPositions[api] {
+			return false
+		}
+	}
+	// all the common array positions are the same
+	if len(t[i].ArrayPositions) < len(t[j].ArrayPositions) {
+		return true // j array positions, longer so greater
+	} else if len(t[i].ArrayPositions) > len(t[j].ArrayPositions) {
+		return false // j array positions, shorter so less
+	}
+
+	// array positions the same, compare starts
+	return t[i].Start < t[j].Start
+}
+
+func (t TermLocations) MergeOverlapping() {
+	var lastTl *TermLocation
+	for i, tl := range t {
+		if lastTl == nil && tl != nil {
+			lastTl = tl
+		} else if lastTl != nil && tl != nil {
+			if lastTl.Overlaps(tl) {
+				// ok merge this with previous
+				lastTl.End = tl.End
+				t[i] = nil
+			}
+		}
+	}
+}
+
+func OrderTermLocations(tlm search.TermLocationMap) TermLocations {
+	rv := make(TermLocations, 0)
+	for term, locations := range tlm {
+		for _, location := range locations {
+			tl := TermLocation{
+				Term:           term,
+				ArrayPositions: location.ArrayPositions,
+				Pos:            int(location.Pos),
+				Start:          int(location.Start),
+				End:            int(location.End),
+			}
+			rv = append(rv, &tl)
+		}
+	}
+	sort.Sort(rv)
+	return rv
+}
+
+func SameArrayPositions(fieldArrayPositions []uint64, termLocationArrayPositions []float64) bool {
+	if len(fieldArrayPositions) != len(termLocationArrayPositions) {
+		return false
+	}
+	for i := 0; i < len(fieldArrayPositions); i++ {
+		if fieldArrayPositions[i] != uint64(termLocationArrayPositions[i]) {
+			return false
+		}
+	}
+	return true
+}

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

@@ -0,0 +1,91 @@
+package search
+
+import (
+	"math"
+)
+
+func LevenshteinDistance(a, b *string) int {
+	la := len(*a)
+	lb := len(*b)
+	d := make([]int, la+1)
+	var lastdiag, olddiag, temp int
+
+	for i := 1; i <= la; i++ {
+		d[i] = i
+	}
+	for i := 1; i <= lb; i++ {
+		d[0] = i
+		lastdiag = i - 1
+		for j := 1; j <= la; j++ {
+			olddiag = d[j]
+			min := d[j] + 1
+			if (d[j-1] + 1) < min {
+				min = d[j-1] + 1
+			}
+			if (*a)[j-1] == (*b)[i-1] {
+				temp = 0
+			} else {
+				temp = 1
+			}
+			if (lastdiag + temp) < min {
+				min = lastdiag + temp
+			}
+			d[j] = min
+			lastdiag = olddiag
+		}
+	}
+	return d[la]
+}
+
+// levenshteinDistanceMax same as levenshteinDistance but
+// attempts to bail early once we know the distance
+// will be greater than max
+// in which case the first return val will be the max
+// and the second will be true, indicating max was exceeded
+func LevenshteinDistanceMax(a, b *string, max int) (int, bool) {
+	la := len(*a)
+	lb := len(*b)
+
+	ld := int(math.Abs(float64(la - lb)))
+	if ld > max {
+		return max, true
+	}
+
+	d := make([]int, la+1)
+	var lastdiag, olddiag, temp int
+
+	for i := 1; i <= la; i++ {
+		d[i] = i
+	}
+	for i := 1; i <= lb; i++ {
+		d[0] = i
+		lastdiag = i - 1
+		rowmin := max + 1
+		for j := 1; j <= la; j++ {
+			olddiag = d[j]
+			min := d[j] + 1
+			if (d[j-1] + 1) < min {
+				min = d[j-1] + 1
+			}
+			if (*a)[j-1] == (*b)[i-1] {
+				temp = 0
+			} else {
+				temp = 1
+			}
+			if (lastdiag + temp) < min {
+				min = lastdiag + temp
+			}
+			if min < rowmin {
+				rowmin = min
+			}
+			d[j] = min
+
+			lastdiag = olddiag
+		}
+		// after each row if rowmin isn't less than max stop
+		if rowmin > max {
+			return max, true
+		}
+	}
+	return d[la], false
+}

vendor/github.com/blevesearch/bleve/search/scorers/scorer_conjunction.go

@@ -0,0 +1,59 @@
+//  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 scorers
+
+import (
+	"github.com/blevesearch/bleve/search"
+)
+
+type ConjunctionQueryScorer struct {
+	explain bool
+}
+
+func NewConjunctionQueryScorer(explain bool) *ConjunctionQueryScorer {
+	return &ConjunctionQueryScorer{
+		explain: explain,
+	}
+}
+
+func (s *ConjunctionQueryScorer) Score(constituents []*search.DocumentMatch) *search.DocumentMatch {
+	rv := search.DocumentMatch{
+		ID: constituents[0].ID,
+	}
+
+	var sum float64
+	var childrenExplanations []*search.Explanation
+	if s.explain {
+		childrenExplanations = make([]*search.Explanation, len(constituents))
+	}
+
+	locations := []search.FieldTermLocationMap{}
+	for i, docMatch := range constituents {
+		sum += docMatch.Score
+		if s.explain {
+			childrenExplanations[i] = docMatch.Expl
+		}
+		if docMatch.Locations != nil {
+			locations = append(locations, docMatch.Locations)
+		}
+	}
+	rv.Score = sum
+	if s.explain {
+		rv.Expl = &search.Explanation{Value: sum, Message: "sum of:", Children: childrenExplanations}
+	}
+
+	if len(locations) == 1 {
+		rv.Locations = locations[0]
+	} else if len(locations) > 1 {
+		rv.Locations = search.MergeLocations(locations)
+	}
+
+	return &rv
+}

vendor/github.com/blevesearch/bleve/search/scorers/scorer_constant.go

@@ -0,0 +1,103 @@
+//  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 scorers
+
+import (
+	"fmt"
+
+	"github.com/blevesearch/bleve/search"
+)
+
+type ConstantScorer struct {
+	constant               float64
+	boost                  float64
+	explain                bool
+	queryNorm              float64
+	queryWeight            float64
+	queryWeightExplanation *search.Explanation
+}
+
+func NewConstantScorer(constant float64, boost float64, explain bool) *ConstantScorer {
+	rv := ConstantScorer{
+		explain:     explain,
+		queryWeight: 1.0,
+		constant:    constant,
+		boost:       boost,
+	}
+
+	return &rv
+}
+
+func (s *ConstantScorer) Weight() float64 {
+	sum := s.boost
+	return sum * sum
+}
+
+func (s *ConstantScorer) SetQueryNorm(qnorm float64) {
+	s.queryNorm = qnorm
+
+	// update the query weight
+	s.queryWeight = s.boost * s.queryNorm
+
+	if s.explain {
+		childrenExplanations := make([]*search.Explanation, 2)
+		childrenExplanations[0] = &search.Explanation{
+			Value:   s.boost,
+			Message: "boost",
+		}
+		childrenExplanations[1] = &search.Explanation{
+			Value:   s.queryNorm,
+			Message: "queryNorm",
+		}
+		s.queryWeightExplanation = &search.Explanation{
+			Value:    s.queryWeight,
+			Message:  fmt.Sprintf("ConstantScore()^%f, product of:", s.boost),
+			Children: childrenExplanations,
+		}
+	}
+}
+
+func (s *ConstantScorer) Score(id string) *search.DocumentMatch {
+	var scoreExplanation *search.Explanation
+
+	score := s.constant
+
+	if s.explain {
+		scoreExplanation = &search.Explanation{
+			Value:   score,
+			Message: fmt.Sprintf("ConstantScore()"),
+		}
+	}
+
+	// if the query weight isn't 1, multiply
+	if s.queryWeight != 1.0 {
+		score = score * s.queryWeight
+		if s.explain {
+			childExplanations := make([]*search.Explanation, 2)
+			childExplanations[0] = s.queryWeightExplanation
+			childExplanations[1] = scoreExplanation
+			scoreExplanation = &search.Explanation{
+				Value:    score,
+				Message:  fmt.Sprintf("weight(^%f), product of:", s.boost),
+				Children: childExplanations,
+			}
+		}
+	}
+
+	rv := search.DocumentMatch{
+		ID:    id,
+		Score: score,
+	}
+	if s.explain {
+		rv.Expl = scoreExplanation
+	}
+
+	return &rv
+}

vendor/github.com/blevesearch/bleve/search/scorers/scorer_disjunction.go

@@ -0,0 +1,71 @@
+//  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 scorers
+
+import (
+	"fmt"
+
+	"github.com/blevesearch/bleve/search"
+)
+
+type DisjunctionQueryScorer struct {
+	explain bool
+}
+
+func NewDisjunctionQueryScorer(explain bool) *DisjunctionQueryScorer {
+	return &DisjunctionQueryScorer{
+		explain: explain,
+	}
+}
+
+func (s *DisjunctionQueryScorer) Score(constituents []*search.DocumentMatch, countMatch, countTotal int) *search.DocumentMatch {
+	rv := search.DocumentMatch{
+		ID: constituents[0].ID,
+	}
+
+	var sum float64
+	var childrenExplanations []*search.Explanation
+	if s.explain {
+		childrenExplanations = make([]*search.Explanation, len(constituents))
+	}
+
+	locations := []search.FieldTermLocationMap{}
+	for i, docMatch := range constituents {
+		sum += docMatch.Score
+		if s.explain {
+			childrenExplanations[i] = docMatch.Expl
+		}
+		if docMatch.Locations != nil {
+			locations = append(locations, docMatch.Locations)
+		}
+	}
+
+	var rawExpl *search.Explanation
+	if s.explain {
+		rawExpl = &search.Explanation{Value: sum, Message: "sum of:", Children: childrenExplanations}
+	}
+
+	coord := float64(countMatch) / float64(countTotal)
+	rv.Score = sum * coord
+	if s.explain {
+		ce := make([]*search.Explanation, 2)
+		ce[0] = rawExpl
+		ce[1] = &search.Explanation{Value: coord, Message: fmt.Sprintf("coord(%d/%d)", countMatch, countTotal)}
+		rv.Expl = &search.Explanation{Value: rv.Score, Message: "product of:", Children: ce}
+	}
+
+	if len(locations) == 1 {
+		rv.Locations = locations[0]
+	} else if len(locations) > 1 {
+		rv.Locations = search.MergeLocations(locations)
+	}
+
+	return &rv
+}

vendor/github.com/blevesearch/bleve/search/scorers/scorer_term.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 scorers
+
+import (
+	"fmt"
+	"math"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/search"
+)
+
+type TermQueryScorer struct {
+	queryTerm              string
+	queryField             string
+	queryBoost             float64
+	docTerm                uint64
+	docTotal               uint64
+	idf                    float64
+	explain                bool
+	idfExplanation         *search.Explanation
+	queryNorm              float64
+	queryWeight            float64
+	queryWeightExplanation *search.Explanation
+}
+
+func NewTermQueryScorer(queryTerm string, queryField string, queryBoost float64, docTotal, docTerm uint64, explain bool) *TermQueryScorer {
+	rv := TermQueryScorer{
+		queryTerm:   queryTerm,
+		queryField:  queryField,
+		queryBoost:  queryBoost,
+		docTerm:     docTerm,
+		docTotal:    docTotal,
+		idf:         1.0 + math.Log(float64(docTotal)/float64(docTerm+1.0)),
+		explain:     explain,
+		queryWeight: 1.0,
+	}
+
+	if explain {
+		rv.idfExplanation = &search.Explanation{
+			Value:   rv.idf,
+			Message: fmt.Sprintf("idf(docFreq=%d, maxDocs=%d)", docTerm, docTotal),
+		}
+	}
+
+	return &rv
+}
+
+func (s *TermQueryScorer) Weight() float64 {
+	sum := s.queryBoost * s.idf
+	return sum * sum
+}
+
+func (s *TermQueryScorer) SetQueryNorm(qnorm float64) {
+	s.queryNorm = qnorm
+
+	// update the query weight
+	s.queryWeight = s.queryBoost * s.idf * s.queryNorm
+
+	if s.explain {
+		childrenExplanations := make([]*search.Explanation, 3)
+		childrenExplanations[0] = &search.Explanation{
+			Value:   s.queryBoost,
+			Message: "boost",
+		}
+		childrenExplanations[1] = s.idfExplanation
+		childrenExplanations[2] = &search.Explanation{
+			Value:   s.queryNorm,
+			Message: "queryNorm",
+		}
+		s.queryWeightExplanation = &search.Explanation{
+			Value:    s.queryWeight,
+			Message:  fmt.Sprintf("queryWeight(%s:%s^%f), product of:", s.queryField, string(s.queryTerm), s.queryBoost),
+			Children: childrenExplanations,
+		}
+	}
+}
+
+func (s *TermQueryScorer) Score(termMatch *index.TermFieldDoc) *search.DocumentMatch {
+	var scoreExplanation *search.Explanation
+
+	// need to compute score
+	var tf float64
+	if termMatch.Freq < MaxSqrtCache {
+		tf = SqrtCache[int(termMatch.Freq)]
+	} else {
+		tf = math.Sqrt(float64(termMatch.Freq))
+	}
+	score := tf * termMatch.Norm * s.idf
+
+	if s.explain {
+		childrenExplanations := make([]*search.Explanation, 3)
+		childrenExplanations[0] = &search.Explanation{
+			Value:   tf,
+			Message: fmt.Sprintf("tf(termFreq(%s:%s)=%d", s.queryField, string(s.queryTerm), termMatch.Freq),
+		}
+		childrenExplanations[1] = &search.Explanation{
+			Value:   termMatch.Norm,
+			Message: fmt.Sprintf("fieldNorm(field=%s, doc=%s)", s.queryField, termMatch.ID),
+		}
+		childrenExplanations[2] = s.idfExplanation
+		scoreExplanation = &search.Explanation{
+			Value:    score,
+			Message:  fmt.Sprintf("fieldWeight(%s:%s in %s), product of:", s.queryField, string(s.queryTerm), termMatch.ID),
+			Children: childrenExplanations,
+		}
+	}
+
+	// if the query weight isn't 1, multiply
+	if s.queryWeight != 1.0 {
+		score = score * s.queryWeight
+		if s.explain {
+			childExplanations := make([]*search.Explanation, 2)
+			childExplanations[0] = s.queryWeightExplanation
+			childExplanations[1] = scoreExplanation
+			scoreExplanation = &search.Explanation{
+				Value:    score,
+				Message:  fmt.Sprintf("weight(%s:%s^%f in %s), product of:", s.queryField, string(s.queryTerm), s.queryBoost, termMatch.ID),
+				Children: childExplanations,
+			}
+		}
+	}
+
+	rv := search.DocumentMatch{
+		ID:    termMatch.ID,
+		Score: score,
+	}
+	if s.explain {
+		rv.Expl = scoreExplanation
+	}
+
+	if termMatch.Vectors != nil && len(termMatch.Vectors) > 0 {
+
+		rv.Locations = make(search.FieldTermLocationMap)
+		for _, v := range termMatch.Vectors {
+			tlm := rv.Locations[v.Field]
+			if tlm == nil {
+				tlm = make(search.TermLocationMap)
+			}
+
+			loc := search.Location{
+				Pos:   float64(v.Pos),
+				Start: float64(v.Start),
+				End:   float64(v.End),
+			}
+
+			if len(v.ArrayPositions) > 0 {
+				loc.ArrayPositions = make([]float64, len(v.ArrayPositions))
+				for i, ap := range v.ArrayPositions {
+					loc.ArrayPositions[i] = float64(ap)
+				}
+			}
+
+			locations := tlm[s.queryTerm]
+			if locations == nil {
+				locations = make(search.Locations, 1)
+				locations[0] = &loc
+			} else {
+				locations = append(locations, &loc)
+			}
+			tlm[s.queryTerm] = locations
+
+			rv.Locations[v.Field] = tlm
+		}
+
+	}
+
+	return &rv
+}

vendor/github.com/blevesearch/bleve/search/scorers/sqrt_cache.go

@@ -0,0 +1,25 @@
+//  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 scorers
+
+import (
+	"math"
+)
+
+var SqrtCache map[int]float64
+
+const MaxSqrtCache = 64
+
+func init() {
+	SqrtCache = make(map[int]float64, MaxSqrtCache)
+	for i := 0; i < MaxSqrtCache; i++ {
+		SqrtCache[i] = math.Sqrt(float64(i))
+	}
+}

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

@@ -0,0 +1,102 @@
+//  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 search
+
+type Location struct {
+	Pos            float64   `json:"pos"`
+	Start          float64   `json:"start"`
+	End            float64   `json:"end"`
+	ArrayPositions []float64 `json:"array_positions"`
+}
+
+// SameArrayElement returns true if two locations are point to
+// the same array element
+func (l *Location) SameArrayElement(other *Location) bool {
+	if len(l.ArrayPositions) != len(other.ArrayPositions) {
+		return false
+	}
+	for i, elem := range l.ArrayPositions {
+		if other.ArrayPositions[i] != elem {
+			return false
+		}
+	}
+	return true
+}
+
+type Locations []*Location
+
+type TermLocationMap map[string]Locations
+
+func (t TermLocationMap) AddLocation(term string, location *Location) {
+	existingLocations, exists := t[term]
+	if exists {
+		existingLocations = append(existingLocations, location)
+		t[term] = existingLocations
+	} else {
+		locations := make(Locations, 1)
+		locations[0] = location
+		t[term] = locations
+	}
+}
+
+type FieldTermLocationMap map[string]TermLocationMap
+
+type FieldFragmentMap map[string][]string
+
+type DocumentMatch struct {
+	Index     string               `json:"index,omitempty"`
+	ID        string               `json:"id"`
+	Score     float64              `json:"score"`
+	Expl      *Explanation         `json:"explanation,omitempty"`
+	Locations FieldTermLocationMap `json:"locations,omitempty"`
+	Fragments FieldFragmentMap     `json:"fragments,omitempty"`
+
+	// Fields contains the values for document fields listed in
+	// SearchRequest.Fields. Text fields are returned as strings, numeric
+	// fields as float64s and date fields as time.RFC3339 formatted strings.
+	Fields map[string]interface{} `json:"fields,omitempty"`
+}
+
+func (dm *DocumentMatch) AddFieldValue(name string, value interface{}) {
+	if dm.Fields == nil {
+		dm.Fields = make(map[string]interface{})
+	}
+	existingVal, ok := dm.Fields[name]
+	if !ok {
+		dm.Fields[name] = value
+		return
+	}
+
+	valSlice, ok := existingVal.([]interface{})
+	if ok {
+		// already a slice, append to it
+		valSlice = append(valSlice, value)
+	} else {
+		// create a slice
+		valSlice = []interface{}{existingVal, value}
+	}
+	dm.Fields[name] = valSlice
+}
+
+type DocumentMatchCollection []*DocumentMatch
+
+func (c DocumentMatchCollection) Len() int           { return len(c) }
+func (c DocumentMatchCollection) Swap(i, j int)      { c[i], c[j] = c[j], c[i] }
+func (c DocumentMatchCollection) Less(i, j int) bool { return c[i].Score > c[j].Score }
+
+type Searcher interface {
+	Next() (*DocumentMatch, error)
+	Advance(ID string) (*DocumentMatch, error)
+	Close() error
+	Weight() float64
+	SetQueryNorm(float64)
+	Count() uint64
+	Min() int
+}

vendor/github.com/blevesearch/bleve/search/searchers/ordered_searchers_list.go

@@ -0,0 +1,30 @@
+//  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 searchers
+
+import (
+	"github.com/blevesearch/bleve/search"
+)
+
+type OrderedSearcherList []search.Searcher
+
+// sort.Interface
+
+func (otrl OrderedSearcherList) Len() int {
+	return len(otrl)
+}
+
+func (otrl OrderedSearcherList) Less(i, j int) bool {
+	return otrl[i].Count() < otrl[j].Count()
+}
+
+func (otrl OrderedSearcherList) Swap(i, j int) {
+	otrl[i], otrl[j] = otrl[j], otrl[i]
+}

vendor/github.com/blevesearch/bleve/search/searchers/search_boolean.go

@@ -0,0 +1,335 @@
+//  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 searchers
+
+import (
+	"math"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/scorers"
+)
+
+type BooleanSearcher struct {
+	initialized     bool
+	indexReader     index.IndexReader
+	mustSearcher    search.Searcher
+	shouldSearcher  search.Searcher
+	mustNotSearcher search.Searcher
+	queryNorm       float64
+	currMust        *search.DocumentMatch
+	currShould      *search.DocumentMatch
+	currMustNot     *search.DocumentMatch
+	currentID       string
+	min             uint64
+	scorer          *scorers.ConjunctionQueryScorer
+}
+
+func NewBooleanSearcher(indexReader index.IndexReader, mustSearcher search.Searcher, shouldSearcher search.Searcher, mustNotSearcher search.Searcher, explain bool) (*BooleanSearcher, error) {
+	// build our searcher
+	rv := BooleanSearcher{
+		indexReader:     indexReader,
+		mustSearcher:    mustSearcher,
+		shouldSearcher:  shouldSearcher,
+		mustNotSearcher: mustNotSearcher,
+		scorer:          scorers.NewConjunctionQueryScorer(explain),
+	}
+	rv.computeQueryNorm()
+	return &rv, nil
+}
+
+func (s *BooleanSearcher) computeQueryNorm() {
+	// first calculate sum of squared weights
+	sumOfSquaredWeights := 0.0
+	if s.mustSearcher != nil {
+		sumOfSquaredWeights += s.mustSearcher.Weight()
+	}
+	if s.shouldSearcher != nil {
+		sumOfSquaredWeights += s.shouldSearcher.Weight()
+	}
+
+	// now compute query norm from this
+	s.queryNorm = 1.0 / math.Sqrt(sumOfSquaredWeights)
+	// finally tell all the downstream searchers the norm
+	if s.mustSearcher != nil {
+		s.mustSearcher.SetQueryNorm(s.queryNorm)
+	}
+	if s.shouldSearcher != nil {
+		s.shouldSearcher.SetQueryNorm(s.queryNorm)
+	}
+}
+
+func (s *BooleanSearcher) initSearchers() error {
+	var err error
+	// get all searchers pointing at their first match
+	if s.mustSearcher != nil {
+		s.currMust, err = s.mustSearcher.Next()
+		if err != nil {
+			return err
+		}
+	}
+
+	if s.shouldSearcher != nil {
+		s.currShould, err = s.shouldSearcher.Next()
+		if err != nil {
+			return err
+		}
+	}
+
+	if s.mustNotSearcher != nil {
+		s.currMustNot, err = s.mustNotSearcher.Next()
+		if err != nil {
+			return err
+		}
+	}
+
+	if s.mustSearcher != nil && s.currMust != nil {
+		s.currentID = s.currMust.ID
+	} else if s.mustSearcher == nil && s.currShould != nil {
+		s.currentID = s.currShould.ID
+	} else {
+		s.currentID = ""
+	}
+
+	s.initialized = true
+	return nil
+}
+
+func (s *BooleanSearcher) advanceNextMust() error {
+	var err error
+
+	if s.mustSearcher != nil {
+		s.currMust, err = s.mustSearcher.Next()
+		if err != nil {
+			return err
+		}
+	} else if s.mustSearcher == nil {
+		s.currShould, err = s.shouldSearcher.Next()
+		if err != nil {
+			return err
+		}
+	}
+
+	if s.mustSearcher != nil && s.currMust != nil {
+		s.currentID = s.currMust.ID
+	} else if s.mustSearcher == nil && s.currShould != nil {
+		s.currentID = s.currShould.ID
+	} else {
+		s.currentID = ""
+	}
+	return nil
+}
+
+func (s *BooleanSearcher) Weight() float64 {
+	var rv float64
+	if s.mustSearcher != nil {
+		rv += s.mustSearcher.Weight()
+	}
+	if s.shouldSearcher != nil {
+		rv += s.shouldSearcher.Weight()
+	}
+
+	return rv
+}
+
+func (s *BooleanSearcher) SetQueryNorm(qnorm float64) {
+	if s.mustSearcher != nil {
+		s.mustSearcher.SetQueryNorm(qnorm)
+	}
+	if s.shouldSearcher != nil {
+		s.shouldSearcher.SetQueryNorm(qnorm)
+	}
+}
+
+func (s *BooleanSearcher) Next() (*search.DocumentMatch, error) {
+
+	if !s.initialized {
+		err := s.initSearchers()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	var err error
+	var rv *search.DocumentMatch
+
+	for s.currentID != "" {
+		if s.currMustNot != nil && s.currMustNot.ID < s.currentID {
+			// advance must not searcher to our candidate entry
+			s.currMustNot, err = s.mustNotSearcher.Advance(s.currentID)
+			if err != nil {
+				return nil, err
+			}
+			if s.currMustNot != nil && s.currMustNot.ID == s.currentID {
+				// the candidate is excluded
+				err = s.advanceNextMust()
+				if err != nil {
+					return nil, err
+				}
+				continue
+			}
+		} else if s.currMustNot != nil && s.currMustNot.ID == s.currentID {
+			// the candidate is excluded
+			err = s.advanceNextMust()
+			if err != nil {
+				return nil, err
+			}
+			continue
+		}
+
+		if s.currShould != nil && s.currShould.ID < s.currentID {
+			// advance should searcher to our candidate entry
+			s.currShould, err = s.shouldSearcher.Advance(s.currentID)
+			if err != nil {
+				return nil, err
+			}
+			if s.currShould != nil && s.currShould.ID == s.currentID {
+				// score bonus matches should
+				var cons []*search.DocumentMatch
+				if s.currMust != nil {
+					cons = []*search.DocumentMatch{
+						s.currMust,
+						s.currShould,
+					}
+				} else {
+					cons = []*search.DocumentMatch{
+						s.currShould,
+					}
+				}
+				rv = s.scorer.Score(cons)
+				err = s.advanceNextMust()
+				if err != nil {
+					return nil, err
+				}
+				break
+			} else if s.shouldSearcher.Min() == 0 {
+				// match is OK anyway
+				rv = s.scorer.Score([]*search.DocumentMatch{s.currMust})
+				err = s.advanceNextMust()
+				if err != nil {
+					return nil, err
+				}
+				break
+			}
+		} else if s.currShould != nil && s.currShould.ID == s.currentID {
+			// score bonus matches should
+			var cons []*search.DocumentMatch
+			if s.currMust != nil {
+				cons = []*search.DocumentMatch{
+					s.currMust,
+					s.currShould,
+				}
+			} else {
+				cons = []*search.DocumentMatch{
+					s.currShould,
+				}
+			}
+			rv = s.scorer.Score(cons)
+			err = s.advanceNextMust()
+			if err != nil {
+				return nil, err
+			}
+			break
+		} else if s.shouldSearcher == nil || s.shouldSearcher.Min() == 0 {
+			// match is OK anyway
+			rv = s.scorer.Score([]*search.DocumentMatch{s.currMust})
+			err = s.advanceNextMust()
+			if err != nil {
+				return nil, err
+			}
+			break
+		}
+
+		err = s.advanceNextMust()
+		if err != nil {
+			return nil, err
+		}
+	}
+	return rv, nil
+}
+
+func (s *BooleanSearcher) Advance(ID string) (*search.DocumentMatch, error) {
+
+	if !s.initialized {
+		err := s.initSearchers()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	var err error
+	if s.mustSearcher != nil {
+		s.currMust, err = s.mustSearcher.Advance(ID)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if s.shouldSearcher != nil {
+		s.currShould, err = s.shouldSearcher.Advance(ID)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if s.mustNotSearcher != nil {
+		s.currMustNot, err = s.mustNotSearcher.Advance(ID)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if s.mustSearcher != nil && s.currMust != nil {
+		s.currentID = s.currMust.ID
+	} else if s.mustSearcher == nil && s.currShould != nil {
+		s.currentID = s.currShould.ID
+	} else {
+		s.currentID = ""
+	}
+
+	return s.Next()
+}
+
+func (s *BooleanSearcher) Count() uint64 {
+
+	// for now return a worst case
+	var sum uint64
+	if s.mustSearcher != nil {
+		sum += s.mustSearcher.Count()
+	}
+	if s.shouldSearcher != nil {
+		sum += s.shouldSearcher.Count()
+	}
+	return sum
+}
+
+func (s *BooleanSearcher) Close() error {
+	if s.mustSearcher != nil {
+		err := s.mustSearcher.Close()
+		if err != nil {
+			return err
+		}
+	}
+	if s.shouldSearcher != nil {
+		err := s.shouldSearcher.Close()
+		if err != nil {
+			return err
+		}
+	}
+	if s.mustNotSearcher != nil {
+		err := s.mustNotSearcher.Close()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *BooleanSearcher) Min() int {
+	return 0
+}

vendor/github.com/blevesearch/bleve/search/searchers/search_conjunction.go

@@ -0,0 +1,197 @@
+//  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 searchers
+
+import (
+	"math"
+	"sort"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/scorers"
+)
+
+type ConjunctionSearcher struct {
+	initialized bool
+	indexReader index.IndexReader
+	searchers   OrderedSearcherList
+	explain     bool
+	queryNorm   float64
+	currs       []*search.DocumentMatch
+	currentID   string
+	scorer      *scorers.ConjunctionQueryScorer
+}
+
+func NewConjunctionSearcher(indexReader index.IndexReader, qsearchers []search.Searcher, explain bool) (*ConjunctionSearcher, error) {
+	// build the downstream searchers
+	searchers := make(OrderedSearcherList, len(qsearchers))
+	for i, searcher := range qsearchers {
+		searchers[i] = searcher
+	}
+	// sort the searchers
+	sort.Sort(searchers)
+	// build our searcher
+	rv := ConjunctionSearcher{
+		indexReader: indexReader,
+		explain:     explain,
+		searchers:   searchers,
+		currs:       make([]*search.DocumentMatch, len(searchers)),
+		scorer:      scorers.NewConjunctionQueryScorer(explain),
+	}
+	rv.computeQueryNorm()
+	return &rv, nil
+}
+
+func (s *ConjunctionSearcher) computeQueryNorm() {
+	// first calculate sum of squared weights
+	sumOfSquaredWeights := 0.0
+	for _, termSearcher := range s.searchers {
+		sumOfSquaredWeights += termSearcher.Weight()
+	}
+	// now compute query norm from this
+	s.queryNorm = 1.0 / math.Sqrt(sumOfSquaredWeights)
+	// finally tell all the downstream searchers the norm
+	for _, termSearcher := range s.searchers {
+		termSearcher.SetQueryNorm(s.queryNorm)
+	}
+}
+
+func (s *ConjunctionSearcher) initSearchers() error {
+	var err error
+	// get all searchers pointing at their first match
+	for i, termSearcher := range s.searchers {
+		s.currs[i], err = termSearcher.Next()
+		if err != nil {
+			return err
+		}
+	}
+
+	if len(s.currs) > 0 {
+		if s.currs[0] != nil {
+			s.currentID = s.currs[0].ID
+		} else {
+			s.currentID = ""
+		}
+	}
+
+	s.initialized = true
+	return nil
+}
+
+func (s *ConjunctionSearcher) Weight() float64 {
+	var rv float64
+	for _, searcher := range s.searchers {
+		rv += searcher.Weight()
+	}
+	return rv
+}
+
+func (s *ConjunctionSearcher) SetQueryNorm(qnorm float64) {
+	for _, searcher := range s.searchers {
+		searcher.SetQueryNorm(qnorm)
+	}
+}
+
+func (s *ConjunctionSearcher) Next() (*search.DocumentMatch, error) {
+	if !s.initialized {
+		err := s.initSearchers()
+		if err != nil {
+			return nil, err
+		}
+	}
+	var rv *search.DocumentMatch
+	var err error
+OUTER:
+	for s.currentID != "" {
+		for i, termSearcher := range s.searchers {
+			if s.currs[i] != nil && s.currs[i].ID != s.currentID {
+				if s.currentID < s.currs[i].ID {
+					s.currentID = s.currs[i].ID
+					continue OUTER
+				}
+				// this reader doesn't have the currentID, try to advance
+				s.currs[i], err = termSearcher.Advance(s.currentID)
+				if err != nil {
+					return nil, err
+				}
+				if s.currs[i] == nil {
+					s.currentID = ""
+					continue OUTER
+				}
+				if s.currs[i].ID != s.currentID {
+					// we just advanced, so it doesn't match, it must be greater
+					// no need to call next
+					s.currentID = s.currs[i].ID
+					continue OUTER
+				}
+			} else if s.currs[i] == nil {
+				s.currentID = ""
+				continue OUTER
+			}
+		}
+		// if we get here, a doc matched all readers, sum the score and add it
+		rv = s.scorer.Score(s.currs)
+
+		// prepare for next entry
+		s.currs[0], err = s.searchers[0].Next()
+		if err != nil {
+			return nil, err
+		}
+		if s.currs[0] == nil {
+			s.currentID = ""
+		} else {
+			s.currentID = s.currs[0].ID
+		}
+		// don't continue now, wait for the next call to Next()
+		break
+	}
+	return rv, nil
+}
+
+func (s *ConjunctionSearcher) Advance(ID string) (*search.DocumentMatch, error) {
+	if !s.initialized {
+		err := s.initSearchers()
+		if err != nil {
+			return nil, err
+		}
+	}
+	var err error
+	for i, searcher := range s.searchers {
+		s.currs[i], err = searcher.Advance(ID)
+		if err != nil {
+			return nil, err
+		}
+	}
+	s.currentID = ID
+	return s.Next()
+}
+
+func (s *ConjunctionSearcher) Count() uint64 {
+	// for now return a worst case
+	var sum uint64
+	for _, searcher := range s.searchers {
+		sum += searcher.Count()
+	}
+	return sum
+}
+
+func (s *ConjunctionSearcher) Close() error {
+	for _, searcher := range s.searchers {
+		err := searcher.Close()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *ConjunctionSearcher) Min() int {
+	return 0
+}

vendor/github.com/blevesearch/bleve/search/searchers/search_disjunction.go

@@ -0,0 +1,198 @@
+//  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 searchers
+
+import (
+	"fmt"
+	"math"
+	"sort"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/scorers"
+)
+
+// DisjunctionMaxClauseCount is a compile time setting that applications can
+// adjust to non-zero value to cause the DisjunctionSearcher to return an
+// error instead of exeucting searches when the size exceeds this value.
+var DisjunctionMaxClauseCount = 0
+
+type DisjunctionSearcher struct {
+	initialized bool
+	indexReader index.IndexReader
+	searchers   OrderedSearcherList
+	queryNorm   float64
+	currs       []*search.DocumentMatch
+	currentID   string
+	scorer      *scorers.DisjunctionQueryScorer
+	min         float64
+}
+
+func NewDisjunctionSearcher(indexReader index.IndexReader, qsearchers []search.Searcher, min float64, explain bool) (*DisjunctionSearcher, error) {
+	if DisjunctionMaxClauseCount != 0 && len(qsearchers) > DisjunctionMaxClauseCount {
+		return nil, fmt.Errorf("TooManyClauses[maxClauseCount is set to %d]", DisjunctionMaxClauseCount)
+	}
+	// build the downstream searchers
+	searchers := make(OrderedSearcherList, len(qsearchers))
+	for i, searcher := range qsearchers {
+		searchers[i] = searcher
+	}
+	// sort the searchers
+	sort.Sort(sort.Reverse(searchers))
+	// build our searcher
+	rv := DisjunctionSearcher{
+		indexReader: indexReader,
+		searchers:   searchers,
+		currs:       make([]*search.DocumentMatch, len(searchers)),
+		scorer:      scorers.NewDisjunctionQueryScorer(explain),
+		min:         min,
+	}
+	rv.computeQueryNorm()
+	return &rv, nil
+}
+
+func (s *DisjunctionSearcher) computeQueryNorm() {
+	// first calculate sum of squared weights
+	sumOfSquaredWeights := 0.0
+	for _, termSearcher := range s.searchers {
+		sumOfSquaredWeights += termSearcher.Weight()
+	}
+	// now compute query norm from this
+	s.queryNorm = 1.0 / math.Sqrt(sumOfSquaredWeights)
+	// finally tell all the downstream searchers the norm
+	for _, termSearcher := range s.searchers {
+		termSearcher.SetQueryNorm(s.queryNorm)
+	}
+}
+
+func (s *DisjunctionSearcher) initSearchers() error {
+	var err error
+	// get all searchers pointing at their first match
+	for i, termSearcher := range s.searchers {
+		s.currs[i], err = termSearcher.Next()
+		if err != nil {
+			return err
+		}
+	}
+
+	s.currentID = s.nextSmallestID()
+	s.initialized = true
+	return nil
+}
+
+func (s *DisjunctionSearcher) nextSmallestID() string {
+	rv := ""
+	for _, curr := range s.currs {
+		if curr != nil && (curr.ID < rv || rv == "") {
+			rv = curr.ID
+		}
+	}
+	return rv
+}
+
+func (s *DisjunctionSearcher) Weight() float64 {
+	var rv float64
+	for _, searcher := range s.searchers {
+		rv += searcher.Weight()
+	}
+	return rv
+}
+
+func (s *DisjunctionSearcher) SetQueryNorm(qnorm float64) {
+	for _, searcher := range s.searchers {
+		searcher.SetQueryNorm(qnorm)
+	}
+}
+
+func (s *DisjunctionSearcher) Next() (*search.DocumentMatch, error) {
+	if !s.initialized {
+		err := s.initSearchers()
+		if err != nil {
+			return nil, err
+		}
+	}
+	var err error
+	var rv *search.DocumentMatch
+	matching := make([]*search.DocumentMatch, 0, len(s.searchers))
+
+	found := false
+	for !found && s.currentID != "" {
+		for _, curr := range s.currs {
+			if curr != nil && curr.ID == s.currentID {
+				matching = append(matching, curr)
+			}
+		}
+
+		if len(matching) >= int(s.min) {
+			found = true
+			// score this match
+			rv = s.scorer.Score(matching, len(matching), len(s.searchers))
+		}
+
+		// reset matching
+		matching = make([]*search.DocumentMatch, 0)
+		// invoke next on all the matching searchers
+		for i, curr := range s.currs {
+			if curr != nil && curr.ID == s.currentID {
+				searcher := s.searchers[i]
+				s.currs[i], err = searcher.Next()
+				if err != nil {
+					return nil, err
+				}
+			}
+		}
+		s.currentID = s.nextSmallestID()
+	}
+	return rv, nil
+}
+
+func (s *DisjunctionSearcher) Advance(ID string) (*search.DocumentMatch, error) {
+	if !s.initialized {
+		err := s.initSearchers()
+		if err != nil {
+			return nil, err
+		}
+	}
+	// get all searchers pointing at their first match
+	var err error
+	for i, termSearcher := range s.searchers {
+		s.currs[i], err = termSearcher.Advance(ID)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	s.currentID = s.nextSmallestID()
+
+	return s.Next()
+}
+
+func (s *DisjunctionSearcher) Count() uint64 {
+	// for now return a worst case
+	var sum uint64
+	for _, searcher := range s.searchers {
+		sum += searcher.Count()
+	}
+	return sum
+}
+
+func (s *DisjunctionSearcher) Close() error {
+	for _, searcher := range s.searchers {
+		err := searcher.Close()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *DisjunctionSearcher) Min() int {
+	return int(s.min) // FIXME just make this an int
+}

vendor/github.com/blevesearch/bleve/search/searchers/search_docid.go

@@ -0,0 +1,102 @@
+//  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 searchers
+
+import (
+	"sort"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/scorers"
+)
+
+// DocIDSearcher returns documents matching a predefined set of identifiers.
+type DocIDSearcher struct {
+	ids     []string
+	current int
+	scorer  *scorers.ConstantScorer
+}
+
+func NewDocIDSearcher(indexReader index.IndexReader, ids []string, boost float64,
+	explain bool) (searcher *DocIDSearcher, err error) {
+
+	kept := make([]string, len(ids))
+	copy(kept, ids)
+	sort.Strings(kept)
+
+	if len(ids) > 0 {
+		var idReader index.DocIDReader
+		endTerm := string(incrementBytes([]byte(kept[len(kept)-1])))
+		idReader, err = indexReader.DocIDReader(kept[0], endTerm)
+		if err != nil {
+			return nil, err
+		}
+		defer func() {
+			if cerr := idReader.Close(); err == nil && cerr != nil {
+				err = cerr
+			}
+		}()
+		j := 0
+		for _, id := range kept {
+			doc, err := idReader.Advance(id)
+			if err != nil {
+				return nil, err
+			}
+			// Non-duplicate match
+			if doc == id && (j == 0 || kept[j-1] != id) {
+				kept[j] = id
+				j++
+			}
+		}
+		kept = kept[:j]
+	}
+
+	scorer := scorers.NewConstantScorer(1.0, boost, explain)
+	return &DocIDSearcher{
+		ids:    kept,
+		scorer: scorer,
+	}, nil
+}
+
+func (s *DocIDSearcher) Count() uint64 {
+	return uint64(len(s.ids))
+}
+
+func (s *DocIDSearcher) Weight() float64 {
+	return s.scorer.Weight()
+}
+
+func (s *DocIDSearcher) SetQueryNorm(qnorm float64) {
+	s.scorer.SetQueryNorm(qnorm)
+}
+
+func (s *DocIDSearcher) Next() (*search.DocumentMatch, error) {
+	if s.current >= len(s.ids) {
+		return nil, nil
+	}
+	id := s.ids[s.current]
+	s.current++
+	docMatch := s.scorer.Score(id)
+	return docMatch, nil
+
+}
+
+func (s *DocIDSearcher) Advance(ID string) (*search.DocumentMatch, error) {
+	s.current = sort.SearchStrings(s.ids, ID)
+	return s.Next()
+}
+
+func (s *DocIDSearcher) Close() error {
+	return nil
+}
+
+func (s *DocIDSearcher) Min() int {
+	return 0
+}

vendor/github.com/blevesearch/bleve/search/searchers/search_fuzzy.go

@@ -0,0 +1,117 @@
+//  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 searchers
+
+import (
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/search"
+)
+
+type FuzzySearcher struct {
+	indexReader index.IndexReader
+	term        string
+	prefix      int
+	fuzziness   int
+	field       string
+	explain     bool
+	searcher    *DisjunctionSearcher
+}
+
+func NewFuzzySearcher(indexReader index.IndexReader, term string, prefix, fuzziness int, field string, boost float64, explain bool) (*FuzzySearcher, error) {
+	prefixTerm := ""
+	for i, r := range term {
+		if i < prefix {
+			prefixTerm += string(r)
+		}
+	}
+
+	// find the terms with this prefix
+	var fieldDict index.FieldDict
+	var err error
+	if len(prefixTerm) > 0 {
+		fieldDict, err = indexReader.FieldDictPrefix(field, []byte(prefixTerm))
+	} else {
+		fieldDict, err = indexReader.FieldDict(field)
+	}
+
+	// enumerate terms and check levenshtein distance
+	candidateTerms := make([]string, 0)
+	tfd, err := fieldDict.Next()
+	for err == nil && tfd != nil {
+		ld, exceeded := search.LevenshteinDistanceMax(&term, &tfd.Term, fuzziness)
+		if !exceeded && ld <= fuzziness {
+			candidateTerms = append(candidateTerms, tfd.Term)
+		}
+		tfd, err = fieldDict.Next()
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	err = fieldDict.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	// enumerate all the terms in the range
+	qsearchers := make([]search.Searcher, 0, 25)
+
+	for _, cterm := range candidateTerms {
+		qsearcher, err := NewTermSearcher(indexReader, cterm, field, boost, explain)
+		if err != nil {
+			return nil, err
+		}
+		qsearchers = append(qsearchers, qsearcher)
+	}
+
+	// build disjunction searcher of these ranges
+	searcher, err := NewDisjunctionSearcher(indexReader, qsearchers, 0, explain)
+	if err != nil {
+		return nil, err
+	}
+
+	return &FuzzySearcher{
+		indexReader: indexReader,
+		term:        term,
+		prefix:      prefix,
+		fuzziness:   fuzziness,
+		field:       field,
+		explain:     explain,
+		searcher:    searcher,
+	}, nil
+}
+func (s *FuzzySearcher) Count() uint64 {
+	return s.searcher.Count()
+}
+
+func (s *FuzzySearcher) Weight() float64 {
+	return s.searcher.Weight()
+}
+
+func (s *FuzzySearcher) SetQueryNorm(qnorm float64) {
+	s.searcher.SetQueryNorm(qnorm)
+}
+
+func (s *FuzzySearcher) Next() (*search.DocumentMatch, error) {
+	return s.searcher.Next()
+
+}
+
+func (s *FuzzySearcher) Advance(ID string) (*search.DocumentMatch, error) {
+	return s.searcher.Next()
+}
+
+func (s *FuzzySearcher) Close() error {
+	return s.searcher.Close()
+}
+
+func (s *FuzzySearcher) Min() int {
+	return 0
+}

vendor/github.com/blevesearch/bleve/search/searchers/search_match_all.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 searchers
+
+import (
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/scorers"
+)
+
+type MatchAllSearcher struct {
+	indexReader index.IndexReader
+	reader      index.DocIDReader
+	scorer      *scorers.ConstantScorer
+}
+
+func NewMatchAllSearcher(indexReader index.IndexReader, boost float64, explain bool) (*MatchAllSearcher, error) {
+	reader, err := indexReader.DocIDReader("", "")
+	if err != nil {
+		return nil, err
+	}
+	scorer := scorers.NewConstantScorer(1.0, boost, explain)
+	return &MatchAllSearcher{
+		indexReader: indexReader,
+		reader:      reader,
+		scorer:      scorer,
+	}, nil
+}
+
+func (s *MatchAllSearcher) Count() uint64 {
+	return s.indexReader.DocCount()
+}
+
+func (s *MatchAllSearcher) Weight() float64 {
+	return s.scorer.Weight()
+}
+
+func (s *MatchAllSearcher) SetQueryNorm(qnorm float64) {
+	s.scorer.SetQueryNorm(qnorm)
+}
+
+func (s *MatchAllSearcher) Next() (*search.DocumentMatch, error) {
+	id, err := s.reader.Next()
+	if err != nil {
+		return nil, err
+	}
+
+	if id == "" {
+		return nil, nil
+	}
+
+	// score match
+	docMatch := s.scorer.Score(id)
+	// return doc match
+	return docMatch, nil
+
+}
+
+func (s *MatchAllSearcher) Advance(ID string) (*search.DocumentMatch, error) {
+	id, err := s.reader.Advance(ID)
+	if err != nil {
+		return nil, err
+	}
+
+	if id == "" {
+		return nil, nil
+	}
+
+	// score match
+	docMatch := s.scorer.Score(id)
+
+	// return doc match
+	return docMatch, nil
+}
+
+func (s *MatchAllSearcher) Close() error {
+	return s.reader.Close()
+}
+
+func (s *MatchAllSearcher) Min() int {
+	return 0
+}

vendor/github.com/blevesearch/bleve/search/searchers/search_match_none.go

@@ -0,0 +1,53 @@
+//  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 searchers
+
+import (
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/search"
+)
+
+type MatchNoneSearcher struct {
+	indexReader index.IndexReader
+}
+
+func NewMatchNoneSearcher(indexReader index.IndexReader) (*MatchNoneSearcher, error) {
+	return &MatchNoneSearcher{
+		indexReader: indexReader,
+	}, nil
+}
+
+func (s *MatchNoneSearcher) Count() uint64 {
+	return uint64(0)
+}
+
+func (s *MatchNoneSearcher) Weight() float64 {
+	return 0.0
+}
+
+func (s *MatchNoneSearcher) SetQueryNorm(qnorm float64) {
+
+}
+
+func (s *MatchNoneSearcher) Next() (*search.DocumentMatch, error) {
+	return nil, nil
+}
+
+func (s *MatchNoneSearcher) Advance(ID string) (*search.DocumentMatch, error) {
+	return nil, nil
+}
+
+func (s *MatchNoneSearcher) Close() error {
+	return nil
+}
+
+func (s *MatchNoneSearcher) Min() int {
+	return 0
+}

vendor/github.com/blevesearch/bleve/search/searchers/search_numeric_range.go

@@ -0,0 +1,214 @@
+//  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 searchers
+
+import (
+	"bytes"
+	"math"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/numeric_util"
+	"github.com/blevesearch/bleve/search"
+)
+
+type NumericRangeSearcher struct {
+	indexReader index.IndexReader
+	min         *float64
+	max         *float64
+	field       string
+	explain     bool
+	searcher    *DisjunctionSearcher
+}
+
+func NewNumericRangeSearcher(indexReader index.IndexReader, min *float64, max *float64, inclusiveMin, inclusiveMax *bool, field string, boost float64, explain bool) (*NumericRangeSearcher, error) {
+	// account for unbounded edges
+	if min == nil {
+		negInf := math.Inf(-1)
+		min = &negInf
+	}
+	if max == nil {
+		Inf := math.Inf(1)
+		max = &Inf
+	}
+	if inclusiveMin == nil {
+		defaultInclusiveMin := true
+		inclusiveMin = &defaultInclusiveMin
+	}
+	if inclusiveMax == nil {
+		defaultInclusiveMax := false
+		inclusiveMax = &defaultInclusiveMax
+	}
+	// find all the ranges
+	minInt64 := numeric_util.Float64ToInt64(*min)
+	if !*inclusiveMin && minInt64 != math.MaxInt64 {
+		minInt64++
+	}
+	maxInt64 := numeric_util.Float64ToInt64(*max)
+	if !*inclusiveMax && maxInt64 != math.MinInt64 {
+		maxInt64--
+	}
+	// FIXME hard-coded precision, should match field declaration
+	termRanges := splitInt64Range(minInt64, maxInt64, 4)
+	terms := termRanges.Enumerate()
+	// enumerate all the terms in the range
+	qsearchers := make([]search.Searcher, len(terms))
+	for i, term := range terms {
+		var err error
+		qsearchers[i], err = NewTermSearcher(indexReader, string(term), field, boost, explain)
+		if err != nil {
+			return nil, err
+		}
+	}
+	// build disjunction searcher of these ranges
+	searcher, err := NewDisjunctionSearcher(indexReader, qsearchers, 0, explain)
+	if err != nil {
+		return nil, err
+	}
+	return &NumericRangeSearcher{
+		indexReader: indexReader,
+		min:         min,
+		max:         max,
+		field:       field,
+		explain:     explain,
+		searcher:    searcher,
+	}, nil
+}
+
+func (s *NumericRangeSearcher) Count() uint64 {
+	return s.searcher.Count()
+}
+
+func (s *NumericRangeSearcher) Weight() float64 {
+	return s.searcher.Weight()
+}
+
+func (s *NumericRangeSearcher) SetQueryNorm(qnorm float64) {
+	s.searcher.SetQueryNorm(qnorm)
+}
+
+func (s *NumericRangeSearcher) Next() (*search.DocumentMatch, error) {
+	return s.searcher.Next()
+}
+
+func (s *NumericRangeSearcher) Advance(ID string) (*search.DocumentMatch, error) {
+	return s.searcher.Advance(ID)
+}
+
+func (s *NumericRangeSearcher) Close() error {
+	return s.searcher.Close()
+}
+
+type termRange struct {
+	startTerm []byte
+	endTerm   []byte
+}
+
+func (t *termRange) Enumerate() [][]byte {
+	rv := make([][]byte, 0)
+	next := t.startTerm
+	for bytes.Compare(next, t.endTerm) <= 0 {
+		rv = append(rv, next)
+		next = incrementBytes(next)
+	}
+	return rv
+}
+
+func incrementBytes(in []byte) []byte {
+	rv := make([]byte, len(in))
+	copy(rv, in)
+	for i := len(rv) - 1; i >= 0; i-- {
+		rv[i] = rv[i] + 1
+		if rv[i] != 0 {
+			// didn't overflow, so stop
+			break
+		}
+	}
+	return rv
+}
+
+type termRanges []*termRange
+
+func (tr termRanges) Enumerate() [][]byte {
+	rv := make([][]byte, 0)
+	for _, tri := range tr {
+		trie := tri.Enumerate()
+		rv = append(rv, trie...)
+	}
+	return rv
+}
+
+func splitInt64Range(minBound, maxBound int64, precisionStep uint) termRanges {
+	rv := make(termRanges, 0)
+	if minBound > maxBound {
+		return rv
+	}
+
+	for shift := uint(0); ; shift += precisionStep {
+
+		diff := int64(1) << (shift + precisionStep)
+		mask := ((int64(1) << precisionStep) - int64(1)) << shift
+		hasLower := (minBound & mask) != int64(0)
+		hasUpper := (maxBound & mask) != mask
+
+		var nextMinBound int64
+		if hasLower {
+			nextMinBound = (minBound + diff) &^ mask
+		} else {
+			nextMinBound = minBound &^ mask
+		}
+		var nextMaxBound int64
+		if hasUpper {
+			nextMaxBound = (maxBound - diff) &^ mask
+		} else {
+			nextMaxBound = maxBound &^ mask
+		}
+
+		lowerWrapped := nextMinBound < minBound
+		upperWrapped := nextMaxBound > maxBound
+
+		if shift+precisionStep >= 64 || nextMinBound > nextMaxBound || lowerWrapped || upperWrapped {
+			// We are in the lowest precision or the next precision is not available.
+			rv = append(rv, newRange(minBound, maxBound, shift))
+			// exit the split recursion loop
+			break
+		}
+
+		if hasLower {
+			rv = append(rv, newRange(minBound, minBound|mask, shift))
+		}
+		if hasUpper {
+			rv = append(rv, newRange(maxBound&^mask, maxBound, shift))
+		}
+
+		// recurse to next precision
+		minBound = nextMinBound
+		maxBound = nextMaxBound
+	}
+
+	return rv
+}
+
+func newRange(minBound, maxBound int64, shift uint) *termRange {
+	maxBound |= (int64(1) << shift) - int64(1)
+	minBytes := numeric_util.MustNewPrefixCodedInt64(minBound, shift)
+	maxBytes := numeric_util.MustNewPrefixCodedInt64(maxBound, shift)
+	return newRangeBytes(minBytes, maxBytes)
+}
+
+func newRangeBytes(minBytes, maxBytes []byte) *termRange {
+	return &termRange{
+		startTerm: minBytes,
+		endTerm:   maxBytes,
+	}
+}
+
+func (s *NumericRangeSearcher) Min() int {
+	return 0
+}

vendor/github.com/blevesearch/bleve/search/searchers/search_phrase.go

@@ -0,0 +1,197 @@
+//  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 searchers
+
+import (
+	"math"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/search"
+)
+
+type PhraseSearcher struct {
+	initialized  bool
+	indexReader  index.IndexReader
+	mustSearcher *ConjunctionSearcher
+	queryNorm    float64
+	currMust     *search.DocumentMatch
+	slop         int
+	terms        []string
+}
+
+func NewPhraseSearcher(indexReader index.IndexReader, mustSearcher *ConjunctionSearcher, terms []string) (*PhraseSearcher, error) {
+	// build our searcher
+	rv := PhraseSearcher{
+		indexReader:  indexReader,
+		mustSearcher: mustSearcher,
+		terms:        terms,
+	}
+	rv.computeQueryNorm()
+	return &rv, nil
+}
+
+func (s *PhraseSearcher) computeQueryNorm() {
+	// first calculate sum of squared weights
+	sumOfSquaredWeights := 0.0
+	if s.mustSearcher != nil {
+		sumOfSquaredWeights += s.mustSearcher.Weight()
+	}
+
+	// now compute query norm from this
+	s.queryNorm = 1.0 / math.Sqrt(sumOfSquaredWeights)
+	// finally tell all the downstream searchers the norm
+	if s.mustSearcher != nil {
+		s.mustSearcher.SetQueryNorm(s.queryNorm)
+	}
+}
+
+func (s *PhraseSearcher) initSearchers() error {
+	var err error
+	// get all searchers pointing at their first match
+	if s.mustSearcher != nil {
+		s.currMust, err = s.mustSearcher.Next()
+		if err != nil {
+			return err
+		}
+	}
+
+	s.initialized = true
+	return nil
+}
+
+func (s *PhraseSearcher) advanceNextMust() error {
+	var err error
+
+	if s.mustSearcher != nil {
+		s.currMust, err = s.mustSearcher.Next()
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (s *PhraseSearcher) Weight() float64 {
+	var rv float64
+	rv += s.mustSearcher.Weight()
+
+	return rv
+}
+
+func (s *PhraseSearcher) SetQueryNorm(qnorm float64) {
+	s.mustSearcher.SetQueryNorm(qnorm)
+}
+
+func (s *PhraseSearcher) Next() (*search.DocumentMatch, error) {
+	if !s.initialized {
+		err := s.initSearchers()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	var rv *search.DocumentMatch
+	for s.currMust != nil {
+		rvftlm := make(search.FieldTermLocationMap, 0)
+		freq := 0
+		firstTerm := s.terms[0]
+		for field, termLocMap := range s.currMust.Locations {
+			rvtlm := make(search.TermLocationMap, 0)
+			locations, ok := termLocMap[firstTerm]
+			if ok {
+			OUTER:
+				for _, location := range locations {
+					crvtlm := make(search.TermLocationMap, 0)
+				INNER:
+					for i := 0; i < len(s.terms); i++ {
+						nextTerm := s.terms[i]
+						if nextTerm != "" {
+							// look through all these term locations
+							// to try and find the correct offsets
+							nextLocations, ok := termLocMap[nextTerm]
+							if ok {
+								for _, nextLocation := range nextLocations {
+									if nextLocation.Pos == location.Pos+float64(i) && nextLocation.SameArrayElement(location) {
+										// found a location match for this term
+										crvtlm.AddLocation(nextTerm, nextLocation)
+										continue INNER
+									}
+								}
+								// if we got here we didn't find a location match for this term
+								continue OUTER
+							} else {
+								continue OUTER
+							}
+						}
+					}
+					// if we got here all the terms matched
+					freq++
+					search.MergeTermLocationMaps(rvtlm, crvtlm)
+					rvftlm[field] = rvtlm
+				}
+			}
+		}
+
+		if freq > 0 {
+			// return match
+			rv = s.currMust
+			rv.Locations = rvftlm
+			err := s.advanceNextMust()
+			if err != nil {
+				return nil, err
+			}
+			return rv, nil
+		}
+
+		err := s.advanceNextMust()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return nil, nil
+}
+
+func (s *PhraseSearcher) Advance(ID string) (*search.DocumentMatch, error) {
+	if !s.initialized {
+		err := s.initSearchers()
+		if err != nil {
+			return nil, err
+		}
+	}
+	var err error
+	s.currMust, err = s.mustSearcher.Advance(ID)
+	if err != nil {
+		return nil, err
+	}
+	return s.Next()
+}
+
+func (s *PhraseSearcher) Count() uint64 {
+	// for now return a worst case
+	var sum uint64
+	sum += s.mustSearcher.Count()
+	return sum
+}
+
+func (s *PhraseSearcher) Close() error {
+	if s.mustSearcher != nil {
+		err := s.mustSearcher.Close()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *PhraseSearcher) Min() int {
+	return 0
+}

vendor/github.com/blevesearch/bleve/search/searchers/search_regexp.go

@@ -0,0 +1,113 @@
+//  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 searchers
+
+import (
+	"regexp"
+
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/search"
+)
+
+type RegexpSearcher struct {
+	indexReader index.IndexReader
+	pattern     *regexp.Regexp
+	field       string
+	explain     bool
+	searcher    *DisjunctionSearcher
+}
+
+func NewRegexpSearcher(indexReader index.IndexReader, pattern *regexp.Regexp, field string, boost float64, explain bool) (*RegexpSearcher, error) {
+
+	prefixTerm, complete := pattern.LiteralPrefix()
+	candidateTerms := make([]string, 0)
+	if complete {
+		// there is no pattern
+		candidateTerms = append(candidateTerms, prefixTerm)
+	} else {
+		var fieldDict index.FieldDict
+		var err error
+		if len(prefixTerm) > 0 {
+			fieldDict, err = indexReader.FieldDictPrefix(field, []byte(prefixTerm))
+		} else {
+			fieldDict, err = indexReader.FieldDict(field)
+		}
+
+		// enumerate the terms and check against regexp
+		tfd, err := fieldDict.Next()
+		for err == nil && tfd != nil {
+			if pattern.MatchString(tfd.Term) {
+				candidateTerms = append(candidateTerms, tfd.Term)
+			}
+			tfd, err = fieldDict.Next()
+		}
+		if err != nil {
+			return nil, err
+		}
+
+		err = fieldDict.Close()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// enumerate all the terms in the range
+	qsearchers := make([]search.Searcher, 0, 25)
+
+	for _, cterm := range candidateTerms {
+		qsearcher, err := NewTermSearcher(indexReader, cterm, field, boost, explain)
+		if err != nil {
+			return nil, err
+		}
+		qsearchers = append(qsearchers, qsearcher)
+	}
+
+	// build disjunction searcher of these ranges
+	searcher, err := NewDisjunctionSearcher(indexReader, qsearchers, 0, explain)
+	if err != nil {
+		return nil, err
+	}
+
+	return &RegexpSearcher{
+		indexReader: indexReader,
+		pattern:     pattern,
+		field:       field,
+		explain:     explain,
+		searcher:    searcher,
+	}, nil
+}
+func (s *RegexpSearcher) Count() uint64 {
+	return s.searcher.Count()
+}
+
+func (s *RegexpSearcher) Weight() float64 {
+	return s.searcher.Weight()
+}
+
+func (s *RegexpSearcher) SetQueryNorm(qnorm float64) {
+	s.searcher.SetQueryNorm(qnorm)
+}
+
+func (s *RegexpSearcher) Next() (*search.DocumentMatch, error) {
+	return s.searcher.Next()
+
+}
+
+func (s *RegexpSearcher) Advance(ID string) (*search.DocumentMatch, error) {
+	return s.searcher.Next()
+}
+
+func (s *RegexpSearcher) Close() error {
+	return s.searcher.Close()
+}
+
+func (s *RegexpSearcher) Min() int {
+	return 0
+}

vendor/github.com/blevesearch/bleve/search/searchers/search_term.go

@@ -0,0 +1,95 @@
+//  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 searchers
+
+import (
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/search"
+	"github.com/blevesearch/bleve/search/scorers"
+)
+
+type TermSearcher struct {
+	indexReader index.IndexReader
+	term        string
+	field       string
+	explain     bool
+	reader      index.TermFieldReader
+	scorer      *scorers.TermQueryScorer
+}
+
+func NewTermSearcher(indexReader index.IndexReader, term string, field string, boost float64, explain bool) (*TermSearcher, error) {
+	reader, err := indexReader.TermFieldReader([]byte(term), field)
+	if err != nil {
+		return nil, err
+	}
+	scorer := scorers.NewTermQueryScorer(term, field, boost, indexReader.DocCount(), reader.Count(), explain)
+	return &TermSearcher{
+		indexReader: indexReader,
+		term:        term,
+		field:       field,
+		explain:     explain,
+		reader:      reader,
+		scorer:      scorer,
+	}, nil
+}
+
+func (s *TermSearcher) Count() uint64 {
+	return s.reader.Count()
+}
+
+func (s *TermSearcher) Weight() float64 {
+	return s.scorer.Weight()
+}
+
+func (s *TermSearcher) SetQueryNorm(qnorm float64) {
+	s.scorer.SetQueryNorm(qnorm)
+}
+
+func (s *TermSearcher) Next() (*search.DocumentMatch, error) {
+	termMatch, err := s.reader.Next()
+	if err != nil {
+		return nil, err
+	}
+
+	if termMatch == nil {
+		return nil, nil
+	}
+
+	// score match
+	docMatch := s.scorer.Score(termMatch)
+	// return doc match
+	return docMatch, nil
+
+}
+
+func (s *TermSearcher) Advance(ID string) (*search.DocumentMatch, error) {
+	termMatch, err := s.reader.Advance(ID)
+	if err != nil {
+		return nil, err
+	}
+
+	if termMatch == nil {
+		return nil, nil
+	}
+
+	// score match
+	docMatch := s.scorer.Score(termMatch)
+
+	// return doc match
+	return docMatch, nil
+}
+
+func (s *TermSearcher) Close() error {
+	return s.reader.Close()
+}
+
+func (s *TermSearcher) Min() int {
+	return 0
+}

vendor/github.com/blevesearch/bleve/search/searchers/search_term_prefix.go

@@ -0,0 +1,88 @@
+//  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 searchers
+
+import (
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/search"
+)
+
+type TermPrefixSearcher struct {
+	indexReader index.IndexReader
+	prefix      string
+	field       string
+	explain     bool
+	searcher    *DisjunctionSearcher
+}
+
+func NewTermPrefixSearcher(indexReader index.IndexReader, prefix string, field string, boost float64, explain bool) (*TermPrefixSearcher, error) {
+	// find the terms with this prefix
+	fieldDict, err := indexReader.FieldDictPrefix(field, []byte(prefix))
+
+	// enumerate all the terms in the range
+	qsearchers := make([]search.Searcher, 0, 25)
+	tfd, err := fieldDict.Next()
+	for err == nil && tfd != nil {
+		var qsearcher *TermSearcher
+		qsearcher, err = NewTermSearcher(indexReader, string(tfd.Term), field, 1.0, explain)
+		if err != nil {
+			return nil, err
+		}
+		qsearchers = append(qsearchers, qsearcher)
+		tfd, err = fieldDict.Next()
+	}
+
+	err = fieldDict.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	// build disjunction searcher of these ranges
+	searcher, err := NewDisjunctionSearcher(indexReader, qsearchers, 0, explain)
+	if err != nil {
+		return nil, err
+	}
+
+	return &TermPrefixSearcher{
+		indexReader: indexReader,
+		prefix:      prefix,
+		field:       field,
+		explain:     explain,
+		searcher:    searcher,
+	}, nil
+}
+func (s *TermPrefixSearcher) Count() uint64 {
+	return s.searcher.Count()
+}
+
+func (s *TermPrefixSearcher) Weight() float64 {
+	return s.searcher.Weight()
+}
+
+func (s *TermPrefixSearcher) SetQueryNorm(qnorm float64) {
+	s.searcher.SetQueryNorm(qnorm)
+}
+
+func (s *TermPrefixSearcher) Next() (*search.DocumentMatch, error) {
+	return s.searcher.Next()
+
+}
+
+func (s *TermPrefixSearcher) Advance(ID string) (*search.DocumentMatch, error) {
+	return s.searcher.Next()
+}
+
+func (s *TermPrefixSearcher) Close() error {
+	return s.searcher.Close()
+}
+
+func (s *TermPrefixSearcher) Min() int {
+	return 0
+}

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

@@ -0,0 +1,37 @@
+//  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 search
+
+func MergeLocations(locations []FieldTermLocationMap) FieldTermLocationMap {
+	rv := locations[0]
+
+	for i := 1; i < len(locations); i++ {
+		nextLocations := locations[i]
+		for field, termLocationMap := range nextLocations {
+			rvTermLocationMap, rvHasField := rv[field]
+			if rvHasField {
+				rv[field] = MergeTermLocationMaps(rvTermLocationMap, termLocationMap)
+			} else {
+				rv[field] = termLocationMap
+			}
+		}
+	}
+
+	return rv
+}
+
+func MergeTermLocationMaps(rv, other TermLocationMap) TermLocationMap {
+	for term, locationMap := range other {
+		// for a given term/document there cannot be different locations
+		// if they came back from different clauses, overwrite is ok
+		rv[term] = locationMap
+	}
+	return rv
+}