Switch from Godep to go vendoring

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

@@ -0,0 +1,147 @@
+//  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 (
+	"container/list"
+	"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,
+	}
+
+	// FIXME better implementation needed here this is quick and dirty
+	topN := list.New()
+
+	// walk entries and find top N
+OUTER:
+	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
+		}
+
+		for e := topN.Front(); e != nil; e = e.Next() {
+			curr := e.Value.(*search.DateRangeFacet)
+			if tf.Count < curr.Count {
+
+				topN.InsertBefore(tf, e)
+				// if we just made the list too long
+				if topN.Len() > fb.size {
+					// remove the head
+					topN.Remove(topN.Front())
+				}
+				continue OUTER
+			}
+		}
+		// if we got to the end, we still have to add it
+		topN.PushBack(tf)
+		if topN.Len() > fb.size {
+			// remove the head
+			topN.Remove(topN.Front())
+		}
+
+	}
+
+	// we now have the list of the top N facets
+	rv.DateRanges = make([]*search.DateRangeFacet, topN.Len())
+	i := 0
+	notOther := 0
+	for e := topN.Back(); e != nil; e = e.Prev() {
+		rv.DateRanges[i] = e.Value.(*search.DateRangeFacet)
+		i++
+		notOther += e.Value.(*search.DateRangeFacet).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_numeric_test.go

@@ -0,0 +1,49 @@
+package facets
+
+import (
+	"strconv"
+	"testing"
+
+	"github.com/blevesearch/bleve/index"
+	nu "github.com/blevesearch/bleve/numeric_util"
+)
+
+var pcodedvalues []nu.PrefixCoded
+
+func init() {
+	pcodedvalues = []nu.PrefixCoded{nu.PrefixCoded{0x20, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1}, nu.PrefixCoded{0x20, 0x0, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f}, nu.PrefixCoded{0x20, 0x0, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7a, 0x1d, 0xa}, nu.PrefixCoded{0x20, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x16, 0x9, 0x4a, 0x7b}}
+}
+
+func BenchmarkNumericFacet10(b *testing.B) {
+	numericFacetN(b, 10)
+}
+
+func BenchmarkNumericFacet100(b *testing.B) {
+	numericFacetN(b, 100)
+}
+
+func BenchmarkNumericFacet1000(b *testing.B) {
+	numericFacetN(b, 1000)
+}
+
+func numericFacetN(b *testing.B, numTerms int) {
+	field := "test"
+	nfb := NewNumericFacetBuilder(field, numTerms)
+	min, max := 0.0, 9999999998.0
+
+	for i := 0; i <= numTerms; i++ {
+		max++
+		min--
+
+		nfb.AddRange("rangename"+strconv.Itoa(i), &min, &max)
+
+		for _, pv := range pcodedvalues {
+			nfb.Update(index.FieldTerms{field: []string{string(pv)}})
+		}
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		nfb.Result()
+	}
+}

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/facet_builder_terms_test.go

@@ -0,0 +1,58 @@
+package facets
+
+import (
+	"io/ioutil"
+	"regexp"
+	"testing"
+
+	"github.com/blevesearch/bleve/index"
+)
+
+var terms []string
+
+func init() {
+	wsRegexp := regexp.MustCompile(`\W+`)
+	input, err := ioutil.ReadFile("benchmark_data.txt")
+	if err != nil {
+		panic(err)
+	}
+	terms = wsRegexp.Split(string(input), -1)
+}
+
+func BenchmarkTermsFacet10(b *testing.B) {
+	termsFacetN(b, 10)
+}
+
+func BenchmarkTermsFacet100(b *testing.B) {
+	termsFacetN(b, 100)
+}
+
+func BenchmarkTermsFacet1000(b *testing.B) {
+	termsFacetN(b, 1000)
+}
+
+func BenchmarkTermsFacet10000(b *testing.B) {
+	termsFacetN(b, 10000)
+}
+
+// func BenchmarkTermsFacet100000(b *testing.B) {
+// 	termsFacetN(b, 100000)
+// }
+
+func termsFacetN(b *testing.B, numTerms int) {
+	field := "test"
+	termsLen := len(terms)
+	tfb := NewTermsFacetBuilder(field, 3)
+	i := 0
+	for len(tfb.termsCount) < numTerms && i <= termsLen {
+		j := i % termsLen
+		term := terms[j]
+		tfb.Update(index.FieldTerms{field: []string{term}})
+		i++
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		tfb.Result()
+	}
+}