2014-07-30 18:30:38 +02:00
|
|
|
// 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.
|
2014-08-25 18:06:10 +02:00
|
|
|
|
2014-07-30 18:30:38 +02:00
|
|
|
package bleve
|
|
|
|
|
|
|
|
import (
|
2015-05-09 20:51:07 +02:00
|
|
|
"fmt"
|
2014-08-20 22:58:20 +02:00
|
|
|
"io/ioutil"
|
2014-12-29 04:34:16 +01:00
|
|
|
"log"
|
2016-08-31 21:21:44 +02:00
|
|
|
"math"
|
2014-07-30 18:30:38 +02:00
|
|
|
"os"
|
2015-03-10 21:22:19 +01:00
|
|
|
"reflect"
|
2015-09-22 19:40:20 +02:00
|
|
|
"sort"
|
2015-04-08 17:17:34 +02:00
|
|
|
"strings"
|
2015-05-09 20:51:07 +02:00
|
|
|
"sync"
|
2014-07-30 18:30:38 +02:00
|
|
|
"testing"
|
2014-12-29 04:34:16 +01:00
|
|
|
"time"
|
2015-09-16 23:10:59 +02:00
|
|
|
|
2016-03-02 22:55:02 +01:00
|
|
|
"golang.org/x/net/context"
|
|
|
|
|
2015-11-21 03:15:35 +01:00
|
|
|
"strconv"
|
2015-12-21 20:59:32 +01:00
|
|
|
|
|
|
|
"github.com/blevesearch/bleve/analysis/analyzers/keyword_analyzer"
|
2016-02-09 21:48:08 +01:00
|
|
|
"github.com/blevesearch/bleve/index"
|
2016-04-08 21:32:13 +02:00
|
|
|
"github.com/blevesearch/bleve/index/store/null"
|
2016-02-09 21:48:08 +01:00
|
|
|
"github.com/blevesearch/bleve/search"
|
2014-07-30 18:30:38 +02:00
|
|
|
)
|
|
|
|
|
2014-11-25 21:56:43 +01:00
|
|
|
func TestCrud(t *testing.T) {
|
2015-04-07 21:39:56 +02:00
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
2014-11-25 21:56:43 +01:00
|
|
|
|
|
|
|
index, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
doca := map[string]interface{}{
|
|
|
|
"name": "marty",
|
|
|
|
"desc": "gophercon india",
|
|
|
|
}
|
|
|
|
err = index.Index("a", doca)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
docy := map[string]interface{}{
|
|
|
|
"name": "jasper",
|
|
|
|
"desc": "clojure",
|
|
|
|
}
|
|
|
|
err = index.Index("y", docy)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.Delete("y")
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
docx := map[string]interface{}{
|
|
|
|
"name": "rose",
|
|
|
|
"desc": "googler",
|
|
|
|
}
|
|
|
|
err = index.Index("x", docx)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.SetInternal([]byte("status"), []byte("pending"))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
docb := map[string]interface{}{
|
|
|
|
"name": "steve",
|
|
|
|
"desc": "cbft master",
|
|
|
|
}
|
2015-03-03 19:18:20 +01:00
|
|
|
batch := index.NewBatch()
|
2015-04-07 20:52:00 +02:00
|
|
|
err = batch.Index("b", docb)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
2014-11-25 21:56:43 +01:00
|
|
|
batch.Delete("x")
|
|
|
|
batch.SetInternal([]byte("batchi"), []byte("batchv"))
|
|
|
|
batch.DeleteInternal([]byte("status"))
|
|
|
|
err = index.Batch(batch)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
val, err := index.GetInternal([]byte("batchi"))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
if string(val) != "batchv" {
|
|
|
|
t.Errorf("expected 'batchv', got '%s'", val)
|
|
|
|
}
|
|
|
|
val, err = index.GetInternal([]byte("status"))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
if val != nil {
|
|
|
|
t.Errorf("expected nil, got '%s'", val)
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.SetInternal([]byte("seqno"), []byte("7"))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
err = index.SetInternal([]byte("status"), []byte("ready"))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
err = index.DeleteInternal([]byte("status"))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
val, err = index.GetInternal([]byte("status"))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
if val != nil {
|
|
|
|
t.Errorf("expected nil, got '%s'", val)
|
|
|
|
}
|
|
|
|
|
|
|
|
val, err = index.GetInternal([]byte("seqno"))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
if string(val) != "7" {
|
|
|
|
t.Errorf("expected '7', got '%s'", val)
|
|
|
|
}
|
2014-11-25 22:23:48 +01:00
|
|
|
|
|
|
|
// close the index, open it again, and try some more things
|
2015-04-07 20:52:00 +02:00
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2014-11-25 22:23:48 +01:00
|
|
|
|
|
|
|
index, err = Open("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2015-04-08 00:05:41 +02:00
|
|
|
defer func() {
|
|
|
|
err := index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
2014-11-25 22:23:48 +01:00
|
|
|
|
|
|
|
count, err := index.DocCount()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if count != 2 {
|
|
|
|
t.Errorf("expected doc count 2, got %d", count)
|
|
|
|
}
|
|
|
|
|
|
|
|
doc, err := index.Document("a")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if doc == nil {
|
|
|
|
t.Errorf("expected doc not nil, got nil")
|
|
|
|
}
|
|
|
|
foundNameField := false
|
|
|
|
for _, field := range doc.Fields {
|
|
|
|
if field.Name() == "name" && string(field.Value()) == "marty" {
|
|
|
|
foundNameField = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !foundNameField {
|
|
|
|
t.Errorf("expected to find field named 'name' with value 'marty'")
|
|
|
|
}
|
2014-11-26 21:36:58 +01:00
|
|
|
|
|
|
|
fields, err := index.Fields()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
expectedFields := map[string]bool{
|
|
|
|
"_all": false,
|
|
|
|
"name": false,
|
|
|
|
"desc": false,
|
|
|
|
}
|
|
|
|
if len(fields) != len(expectedFields) {
|
|
|
|
t.Fatalf("expected %d fields got %d", len(expectedFields), len(fields))
|
|
|
|
}
|
|
|
|
for _, f := range fields {
|
|
|
|
expectedFields[f] = true
|
|
|
|
}
|
|
|
|
for ef, efp := range expectedFields {
|
|
|
|
if !efp {
|
|
|
|
t.Errorf("field %s is missing", ef)
|
|
|
|
}
|
|
|
|
}
|
2014-11-25 21:56:43 +01:00
|
|
|
}
|
|
|
|
|
2014-08-20 22:58:20 +02:00
|
|
|
func TestIndexCreateNewOverExisting(t *testing.T) {
|
2015-04-07 21:39:56 +02:00
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
2014-08-20 22:58:20 +02:00
|
|
|
|
|
|
|
index, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2015-04-07 20:52:00 +02:00
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2014-08-20 22:58:20 +02:00
|
|
|
index, err = New("testidx", NewIndexMapping())
|
2014-09-02 20:14:05 +02:00
|
|
|
if err != ErrorIndexPathExists {
|
2014-08-20 22:58:20 +02:00
|
|
|
t.Fatalf("expected error index path exists, got %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestIndexOpenNonExisting(t *testing.T) {
|
|
|
|
_, err := Open("doesnotexist")
|
2014-09-02 20:14:05 +02:00
|
|
|
if err != ErrorIndexPathDoesNotExist {
|
2014-08-20 22:58:20 +02:00
|
|
|
t.Fatalf("expected error index path does not exist, got %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestIndexOpenMetaMissingOrCorrupt(t *testing.T) {
|
2015-04-07 21:39:56 +02:00
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
2014-08-20 22:58:20 +02:00
|
|
|
|
|
|
|
index, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2015-04-07 20:52:00 +02:00
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2014-08-20 22:58:20 +02:00
|
|
|
|
2014-11-21 22:47:20 +01:00
|
|
|
// now intentionally change the storage type
|
2015-04-07 20:52:00 +02:00
|
|
|
err = ioutil.WriteFile("testidx/index_meta.json", []byte(`{"storage":"mystery"}`), 0666)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2014-11-21 22:47:20 +01:00
|
|
|
|
|
|
|
index, err = Open("testidx")
|
|
|
|
if err != ErrorUnknownStorageType {
|
2015-01-06 18:18:18 +01:00
|
|
|
t.Fatalf("expected error unknown storage type, got %v", err)
|
2014-11-21 22:47:20 +01:00
|
|
|
}
|
|
|
|
|
2014-08-20 22:58:20 +02:00
|
|
|
// now intentionally corrupt the metadata
|
2015-04-07 20:52:00 +02:00
|
|
|
err = ioutil.WriteFile("testidx/index_meta.json", []byte("corrupted"), 0666)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2014-08-20 22:58:20 +02:00
|
|
|
|
|
|
|
index, err = Open("testidx")
|
2014-09-02 20:14:05 +02:00
|
|
|
if err != ErrorIndexMetaCorrupt {
|
2014-08-20 22:58:20 +02:00
|
|
|
t.Fatalf("expected error index metadata corrupted, got %v", err)
|
|
|
|
}
|
|
|
|
|
2014-12-18 18:43:12 +01:00
|
|
|
// now intentionally remove the metadata
|
2015-04-07 20:52:00 +02:00
|
|
|
err = os.Remove("testidx/index_meta.json")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2014-08-20 22:58:20 +02:00
|
|
|
|
|
|
|
index, err = Open("testidx")
|
2014-09-02 20:14:05 +02:00
|
|
|
if err != ErrorIndexMetaMissing {
|
2014-08-20 22:58:20 +02:00
|
|
|
t.Fatalf("expected error index metadata missing, got %v", err)
|
|
|
|
}
|
|
|
|
}
|
2014-11-21 22:47:20 +01:00
|
|
|
|
|
|
|
func TestInMemIndex(t *testing.T) {
|
|
|
|
|
|
|
|
index, err := New("", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2015-04-07 20:52:00 +02:00
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2014-11-21 22:47:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestClosedIndex(t *testing.T) {
|
|
|
|
index, err := New("", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2015-04-07 20:52:00 +02:00
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2014-11-21 22:47:20 +01:00
|
|
|
|
|
|
|
err = index.Index("test", "test")
|
|
|
|
if err != ErrorIndexClosed {
|
|
|
|
t.Errorf("expected error index closed, got %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.Delete("test")
|
|
|
|
if err != ErrorIndexClosed {
|
|
|
|
t.Errorf("expected error index closed, got %v", err)
|
|
|
|
}
|
|
|
|
|
2015-03-03 19:18:20 +01:00
|
|
|
b := index.NewBatch()
|
2014-11-21 22:47:20 +01:00
|
|
|
err = index.Batch(b)
|
|
|
|
if err != ErrorIndexClosed {
|
|
|
|
t.Errorf("expected error index closed, got %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
_, err = index.Document("test")
|
|
|
|
if err != ErrorIndexClosed {
|
|
|
|
t.Errorf("expected error index closed, got %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
_, err = index.DocCount()
|
|
|
|
if err != ErrorIndexClosed {
|
|
|
|
t.Errorf("expected error index closed, got %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
_, err = index.Search(NewSearchRequest(NewTermQuery("test")))
|
|
|
|
if err != ErrorIndexClosed {
|
|
|
|
t.Errorf("expected error index closed, got %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
_, err = index.Fields()
|
|
|
|
if err != ErrorIndexClosed {
|
|
|
|
t.Errorf("expected error index closed, got %v", err)
|
|
|
|
}
|
|
|
|
}
|
2014-12-29 04:34:16 +01:00
|
|
|
|
2016-02-09 21:48:08 +01:00
|
|
|
type slowQuery struct {
|
|
|
|
actual Query
|
|
|
|
delay time.Duration
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *slowQuery) Boost() float64 {
|
|
|
|
return s.actual.Boost()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *slowQuery) SetBoost(b float64) Query {
|
|
|
|
return s.actual.SetBoost(b)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *slowQuery) Field() string {
|
|
|
|
return s.actual.Field()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *slowQuery) SetField(f string) Query {
|
|
|
|
return s.actual.SetField(f)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *slowQuery) Searcher(i index.IndexReader, m *IndexMapping, explain bool) (search.Searcher, error) {
|
|
|
|
time.Sleep(s.delay)
|
|
|
|
return s.actual.Searcher(i, m, explain)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *slowQuery) Validate() error {
|
|
|
|
return s.actual.Validate()
|
|
|
|
}
|
|
|
|
|
2014-12-29 04:34:16 +01:00
|
|
|
func TestSlowSearch(t *testing.T) {
|
2015-04-07 21:39:56 +02:00
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
2014-12-29 04:34:16 +01:00
|
|
|
|
|
|
|
defer func() {
|
|
|
|
// reset logger back to normal
|
|
|
|
SetLog(log.New(ioutil.Discard, "bleve", log.LstdFlags))
|
|
|
|
}()
|
|
|
|
// set custom logger
|
|
|
|
var sdw sawDataWriter
|
|
|
|
SetLog(log.New(&sdw, "bleve", log.LstdFlags))
|
|
|
|
|
|
|
|
index, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2015-04-08 00:05:41 +02:00
|
|
|
defer func() {
|
|
|
|
err := index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
2014-12-29 04:34:16 +01:00
|
|
|
|
|
|
|
Config.SlowSearchLogThreshold = 1 * time.Minute
|
|
|
|
|
|
|
|
query := NewTermQuery("water")
|
|
|
|
req := NewSearchRequest(query)
|
2015-04-07 20:52:00 +02:00
|
|
|
_, err = index.Search(req)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2014-12-29 04:34:16 +01:00
|
|
|
|
|
|
|
if sdw.sawData {
|
|
|
|
t.Errorf("expected to not see slow query logged, but did")
|
|
|
|
}
|
|
|
|
|
2016-02-09 21:48:08 +01:00
|
|
|
sq := &slowQuery{
|
|
|
|
actual: query,
|
|
|
|
delay: 50 * time.Millisecond, // on Windows timer resolution is 15ms
|
|
|
|
}
|
|
|
|
req.Query = sq
|
2014-12-29 04:34:16 +01:00
|
|
|
Config.SlowSearchLogThreshold = 1 * time.Microsecond
|
2015-04-07 20:52:00 +02:00
|
|
|
_, err = index.Search(req)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2014-12-29 04:34:16 +01:00
|
|
|
|
|
|
|
if !sdw.sawData {
|
|
|
|
t.Errorf("expected to see slow query logged, but didn't")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type sawDataWriter struct {
|
|
|
|
sawData bool
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *sawDataWriter) Write(p []byte) (n int, err error) {
|
|
|
|
s.sawData = true
|
|
|
|
return len(p), nil
|
|
|
|
}
|
2015-01-19 21:40:18 +01:00
|
|
|
|
|
|
|
func TestStoredFieldPreserved(t *testing.T) {
|
2015-04-07 21:39:56 +02:00
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
2015-01-19 21:40:18 +01:00
|
|
|
|
|
|
|
index, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2015-04-08 00:05:41 +02:00
|
|
|
defer func() {
|
|
|
|
err := index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
2015-01-19 21:40:18 +01:00
|
|
|
|
|
|
|
doca := map[string]interface{}{
|
|
|
|
"name": "Marty",
|
|
|
|
"desc": "GopherCON India",
|
2016-01-12 02:18:03 +01:00
|
|
|
"bool": true,
|
|
|
|
"num": float64(1),
|
2015-01-19 21:40:18 +01:00
|
|
|
}
|
|
|
|
err = index.Index("a", doca)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
q := NewTermQuery("marty")
|
|
|
|
req := NewSearchRequest(q)
|
2016-01-12 02:18:03 +01:00
|
|
|
req.Fields = []string{"name", "desc", "bool", "num"}
|
2015-01-19 21:40:18 +01:00
|
|
|
res, err := index.Search(req)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(res.Hits) != 1 {
|
2015-10-02 15:35:48 +02:00
|
|
|
t.Fatalf("expected 1 hit, got %d", len(res.Hits))
|
2015-01-19 21:40:18 +01:00
|
|
|
}
|
|
|
|
if res.Hits[0].Fields["name"] != "Marty" {
|
|
|
|
t.Errorf("expected 'Marty' got '%s'", res.Hits[0].Fields["name"])
|
|
|
|
}
|
|
|
|
if res.Hits[0].Fields["desc"] != "GopherCON India" {
|
|
|
|
t.Errorf("expected 'GopherCON India' got '%s'", res.Hits[0].Fields["desc"])
|
|
|
|
}
|
2016-01-12 02:18:03 +01:00
|
|
|
if res.Hits[0].Fields["num"] != float64(1) {
|
|
|
|
t.Errorf("expected '1' got '%v'", res.Hits[0].Fields["num"])
|
|
|
|
}
|
|
|
|
if res.Hits[0].Fields["bool"] != true {
|
|
|
|
t.Errorf("expected 'true' got '%v'", res.Hits[0].Fields["bool"])
|
|
|
|
}
|
2015-01-19 21:40:18 +01:00
|
|
|
}
|
2015-03-10 21:22:19 +01:00
|
|
|
|
|
|
|
func TestDict(t *testing.T) {
|
2015-04-07 21:39:56 +02:00
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
2015-03-10 21:22:19 +01:00
|
|
|
|
|
|
|
index, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
doca := map[string]interface{}{
|
|
|
|
"name": "marty",
|
|
|
|
"desc": "gophercon india",
|
|
|
|
}
|
|
|
|
err = index.Index("a", doca)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
docy := map[string]interface{}{
|
|
|
|
"name": "jasper",
|
|
|
|
"desc": "clojure",
|
|
|
|
}
|
|
|
|
err = index.Index("y", docy)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
docx := map[string]interface{}{
|
|
|
|
"name": "rose",
|
|
|
|
"desc": "googler",
|
|
|
|
}
|
|
|
|
err = index.Index("x", docx)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
dict, err := index.FieldDict("name")
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
terms := []string{}
|
|
|
|
de, err := dict.Next()
|
|
|
|
for err == nil && de != nil {
|
|
|
|
terms = append(terms, string(de.Term))
|
|
|
|
de, err = dict.Next()
|
|
|
|
}
|
|
|
|
|
|
|
|
expectedTerms := []string{"jasper", "marty", "rose"}
|
|
|
|
if !reflect.DeepEqual(terms, expectedTerms) {
|
|
|
|
t.Errorf("expected %v, got %v", expectedTerms, terms)
|
|
|
|
}
|
|
|
|
|
|
|
|
err = dict.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
2015-03-12 05:06:44 +01:00
|
|
|
// test start and end range
|
|
|
|
dict, err = index.FieldDictRange("name", []byte("marty"), []byte("rose"))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
terms = []string{}
|
|
|
|
de, err = dict.Next()
|
|
|
|
for err == nil && de != nil {
|
|
|
|
terms = append(terms, string(de.Term))
|
|
|
|
de, err = dict.Next()
|
|
|
|
}
|
|
|
|
|
|
|
|
expectedTerms = []string{"marty", "rose"}
|
|
|
|
if !reflect.DeepEqual(terms, expectedTerms) {
|
|
|
|
t.Errorf("expected %v, got %v", expectedTerms, terms)
|
|
|
|
}
|
|
|
|
|
|
|
|
err = dict.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
2015-03-12 05:07:09 +01:00
|
|
|
docz := map[string]interface{}{
|
|
|
|
"name": "prefix",
|
|
|
|
"desc": "bob cat cats catting dog doggy zoo",
|
|
|
|
}
|
|
|
|
err = index.Index("z", docz)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
dict, err = index.FieldDictPrefix("desc", []byte("cat"))
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
terms = []string{}
|
|
|
|
de, err = dict.Next()
|
|
|
|
for err == nil && de != nil {
|
|
|
|
terms = append(terms, string(de.Term))
|
|
|
|
de, err = dict.Next()
|
|
|
|
}
|
|
|
|
|
|
|
|
expectedTerms = []string{"cat", "cats", "catting"}
|
|
|
|
if !reflect.DeepEqual(terms, expectedTerms) {
|
|
|
|
t.Errorf("expected %v, got %v", expectedTerms, terms)
|
|
|
|
}
|
|
|
|
|
2015-03-12 22:41:09 +01:00
|
|
|
stats := index.Stats()
|
|
|
|
if stats == nil {
|
|
|
|
t.Errorf("expected IndexStat, got nil")
|
|
|
|
}
|
|
|
|
|
2015-03-12 05:06:44 +01:00
|
|
|
err = dict.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
2015-03-10 21:22:19 +01:00
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
2015-04-08 16:41:42 +02:00
|
|
|
|
|
|
|
func TestBatchString(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
index, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2016-02-09 19:33:11 +01:00
|
|
|
defer func() {
|
|
|
|
err := index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
2015-04-08 16:41:42 +02:00
|
|
|
|
|
|
|
batch := index.NewBatch()
|
|
|
|
err = batch.Index("a", []byte("{}"))
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
batch.Delete("b")
|
|
|
|
batch.SetInternal([]byte("c"), []byte{})
|
|
|
|
batch.DeleteInternal([]byte("d"))
|
|
|
|
|
|
|
|
batchStr := batch.String()
|
2015-04-08 17:17:34 +02:00
|
|
|
if !strings.HasPrefix(batchStr, "Batch (2 ops, 2 internal ops)") {
|
|
|
|
t.Errorf("expected to start with Batch (2 ops, 2 internal ops), did not")
|
2015-04-08 16:41:42 +02:00
|
|
|
}
|
2015-04-08 17:17:34 +02:00
|
|
|
if !strings.Contains(batchStr, "INDEX - 'a'") {
|
|
|
|
t.Errorf("expected to contain INDEX - 'a', did not")
|
|
|
|
}
|
|
|
|
if !strings.Contains(batchStr, "DELETE - 'b'") {
|
|
|
|
t.Errorf("expected to contain DELETE - 'b', did not")
|
|
|
|
}
|
|
|
|
if !strings.Contains(batchStr, "SET INTERNAL - 'c'") {
|
|
|
|
t.Errorf("expected to contain SET INTERNAL - 'c', did not")
|
|
|
|
}
|
|
|
|
if !strings.Contains(batchStr, "DELETE INTERNAL - 'd'") {
|
|
|
|
t.Errorf("expected to contain DELETE INTERNAL - 'd', did not")
|
|
|
|
}
|
|
|
|
|
2015-04-08 16:41:42 +02:00
|
|
|
}
|
2015-05-08 14:07:20 +02:00
|
|
|
|
|
|
|
func TestIndexMetadataRaceBug198(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
index, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2016-02-09 19:33:11 +01:00
|
|
|
defer func() {
|
|
|
|
err := index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
2015-05-08 14:07:20 +02:00
|
|
|
|
2016-02-09 19:33:11 +01:00
|
|
|
done := make(chan struct{})
|
2015-05-08 14:07:20 +02:00
|
|
|
go func() {
|
|
|
|
for {
|
2016-02-09 19:33:11 +01:00
|
|
|
select {
|
|
|
|
case <-done:
|
|
|
|
return
|
|
|
|
default:
|
|
|
|
_, err := index.DocCount()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2015-05-08 14:40:46 +02:00
|
|
|
}
|
2015-05-08 14:07:20 +02:00
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
for i := 0; i < 100; i++ {
|
|
|
|
batch := index.NewBatch()
|
|
|
|
err = batch.Index("a", []byte("{}"))
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
err = index.Batch(batch)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
2016-02-09 19:33:11 +01:00
|
|
|
close(done)
|
2015-05-08 14:07:20 +02:00
|
|
|
}
|
2015-05-09 20:51:07 +02:00
|
|
|
|
2016-08-09 15:18:53 +02:00
|
|
|
func TestSortMatchSearch(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
index, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
2016-08-11 10:35:08 +02:00
|
|
|
names := []string{"Noam", "Uri", "David", "Yosef", "Eitan", "Itay", "Ariel", "Daniel", "Omer", "Yogev", "Yehonatan", "Moshe", "Mohammed", "Yusuf", "Omar"}
|
|
|
|
days := []string{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}
|
|
|
|
numbers := []string{"One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Eleven", "Twelve"}
|
2016-08-09 15:18:53 +02:00
|
|
|
for i := 0; i < 200; i++ {
|
|
|
|
doc := make(map[string]interface{})
|
2016-08-11 10:35:08 +02:00
|
|
|
doc["Name"] = names[i%len(names)]
|
|
|
|
doc["Day"] = days[i%len(days)]
|
|
|
|
doc["Number"] = numbers[i%len(numbers)]
|
2016-08-09 15:18:53 +02:00
|
|
|
err = index.Index(fmt.Sprintf("%d", i), doc)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-11 10:35:08 +02:00
|
|
|
req := NewSearchRequest(NewMatchQuery("One"))
|
2016-08-17 23:49:06 +02:00
|
|
|
req.SortBy([]string{"Day", "Name"})
|
2016-08-09 15:18:53 +02:00
|
|
|
req.Fields = []string{"*"}
|
|
|
|
sr, err := index.Search(req)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
prev := ""
|
|
|
|
for _, hit := range sr.Hits {
|
|
|
|
val := hit.Fields["Day"].(string)
|
|
|
|
if prev > val {
|
|
|
|
t.Errorf("Hits must be sorted by 'Day'. Found '%s' before '%s'", prev, val)
|
|
|
|
}
|
|
|
|
prev = val
|
|
|
|
}
|
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-09 20:51:07 +02:00
|
|
|
func TestIndexCountMatchSearch(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
index, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
for i := 0; i < 10; i++ {
|
|
|
|
wg.Add(1)
|
|
|
|
go func(i int) {
|
|
|
|
b := index.NewBatch()
|
|
|
|
for j := 0; j < 200; j++ {
|
|
|
|
id := fmt.Sprintf("%d", (i*200)+j)
|
|
|
|
doc := struct {
|
|
|
|
Body string
|
|
|
|
}{
|
|
|
|
Body: "match",
|
|
|
|
}
|
|
|
|
err := b.Index(id, doc)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
err := index.Batch(b)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
wg.Done()
|
|
|
|
}(i)
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
|
|
|
|
// search for something that should match all documents
|
|
|
|
sr, err := index.Search(NewSearchRequest(NewMatchQuery("match")))
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// get the index document count
|
|
|
|
dc, err := index.DocCount()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// make sure test is working correctly, doc count should 2000
|
|
|
|
if dc != 2000 {
|
|
|
|
t.Errorf("expected doc count 2000, got %d", dc)
|
|
|
|
}
|
|
|
|
|
|
|
|
// make sure our search found all the documents
|
|
|
|
if dc != sr.Total {
|
|
|
|
t.Errorf("expected search result total %d to match doc count %d", sr.Total, dc)
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
2015-05-15 21:04:52 +02:00
|
|
|
|
|
|
|
func TestBatchReset(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
index, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
batch := index.NewBatch()
|
|
|
|
err = batch.Index("k1", struct {
|
|
|
|
Body string
|
|
|
|
}{
|
|
|
|
Body: "v1",
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
batch.Delete("k2")
|
|
|
|
batch.SetInternal([]byte("k3"), []byte("v3"))
|
|
|
|
batch.DeleteInternal([]byte("k4"))
|
|
|
|
|
|
|
|
if batch.Size() != 4 {
|
|
|
|
t.Logf("%v", batch)
|
|
|
|
t.Errorf("expected batch size 4, got %d", batch.Size())
|
|
|
|
}
|
|
|
|
|
|
|
|
batch.Reset()
|
|
|
|
|
|
|
|
if batch.Size() != 0 {
|
|
|
|
t.Errorf("expected batch size 0 after reset, got %d", batch.Size())
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
2015-05-15 21:47:54 +02:00
|
|
|
|
|
|
|
func TestDocumentFieldArrayPositions(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
index, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// index a document with an array of strings
|
|
|
|
err = index.Index("k", struct {
|
|
|
|
Messages []string
|
|
|
|
}{
|
|
|
|
Messages: []string{
|
|
|
|
"first",
|
|
|
|
"second",
|
|
|
|
"third",
|
|
|
|
"last",
|
|
|
|
},
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// load the document
|
|
|
|
doc, err := index.Document("k")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, f := range doc.Fields {
|
|
|
|
if reflect.DeepEqual(f.Value(), []byte("first")) {
|
|
|
|
ap := f.ArrayPositions()
|
|
|
|
if len(ap) < 1 {
|
|
|
|
t.Errorf("expected an array position, got none")
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if ap[0] != 0 {
|
|
|
|
t.Errorf("expected 'first' in array position 0, got %d", ap[0])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if reflect.DeepEqual(f.Value(), []byte("second")) {
|
|
|
|
ap := f.ArrayPositions()
|
|
|
|
if len(ap) < 1 {
|
|
|
|
t.Errorf("expected an array position, got none")
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if ap[0] != 1 {
|
|
|
|
t.Errorf("expected 'second' in array position 1, got %d", ap[0])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if reflect.DeepEqual(f.Value(), []byte("third")) {
|
|
|
|
ap := f.ArrayPositions()
|
|
|
|
if len(ap) < 1 {
|
|
|
|
t.Errorf("expected an array position, got none")
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if ap[0] != 2 {
|
|
|
|
t.Errorf("expected 'third' in array position 2, got %d", ap[0])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if reflect.DeepEqual(f.Value(), []byte("last")) {
|
|
|
|
ap := f.ArrayPositions()
|
|
|
|
if len(ap) < 1 {
|
|
|
|
t.Errorf("expected an array position, got none")
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if ap[0] != 3 {
|
|
|
|
t.Errorf("expected 'last' in array position 3, got %d", ap[0])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// now index a document in the same field with a single string
|
|
|
|
err = index.Index("k2", struct {
|
|
|
|
Messages string
|
|
|
|
}{
|
|
|
|
Messages: "only",
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// load the document
|
|
|
|
doc, err = index.Document("k2")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, f := range doc.Fields {
|
|
|
|
if reflect.DeepEqual(f.Value(), []byte("only")) {
|
|
|
|
ap := f.ArrayPositions()
|
|
|
|
if len(ap) != 0 {
|
|
|
|
t.Errorf("expected no array positions, got %d", len(ap))
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
2015-05-21 13:49:41 +02:00
|
|
|
|
|
|
|
func TestKeywordSearchBug207(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
f := NewTextFieldMapping()
|
2015-09-16 23:10:59 +02:00
|
|
|
f.Analyzer = keyword_analyzer.Name
|
2015-05-21 13:49:41 +02:00
|
|
|
|
|
|
|
m := NewIndexMapping()
|
|
|
|
m.DefaultMapping = NewDocumentMapping()
|
|
|
|
m.DefaultMapping.AddFieldMappingsAt("Body", f)
|
|
|
|
|
|
|
|
index, err := New("testidx", m)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
doc1 := struct {
|
|
|
|
Body string
|
|
|
|
}{
|
|
|
|
Body: "a555c3bb06f7a127cda000005",
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.Index("a", doc1)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
doc2 := struct {
|
|
|
|
Body string
|
|
|
|
}{
|
|
|
|
Body: "555c3bb06f7a127cda000005",
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.Index("b", doc2)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// now search for these terms
|
|
|
|
sreq := NewSearchRequest(NewTermQuery("a555c3bb06f7a127cda000005"))
|
|
|
|
sres, err := index.Search(sreq)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if sres.Total != 1 {
|
|
|
|
t.Errorf("expected 1 result, got %d", sres.Total)
|
|
|
|
}
|
|
|
|
if sres.Hits[0].ID != "a" {
|
|
|
|
t.Errorf("expecated id 'a', got '%s'", sres.Hits[0].ID)
|
|
|
|
}
|
|
|
|
|
|
|
|
sreq = NewSearchRequest(NewTermQuery("555c3bb06f7a127cda000005"))
|
|
|
|
sres, err = index.Search(sreq)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if sres.Total != 1 {
|
|
|
|
t.Errorf("expected 1 result, got %d", sres.Total)
|
|
|
|
}
|
|
|
|
if sres.Hits[0].ID != "b" {
|
|
|
|
t.Errorf("expecated id 'b', got '%s'", sres.Hits[0].ID)
|
|
|
|
}
|
|
|
|
|
2015-05-21 21:43:13 +02:00
|
|
|
// now do the same searches using query strings
|
|
|
|
sreq = NewSearchRequest(NewQueryStringQuery("Body:a555c3bb06f7a127cda000005"))
|
|
|
|
sres, err = index.Search(sreq)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if sres.Total != 1 {
|
|
|
|
t.Errorf("expected 1 result, got %d", sres.Total)
|
|
|
|
}
|
|
|
|
if sres.Hits[0].ID != "a" {
|
|
|
|
t.Errorf("expecated id 'a', got '%s'", sres.Hits[0].ID)
|
|
|
|
}
|
|
|
|
|
|
|
|
sreq = NewSearchRequest(NewQueryStringQuery(`Body:555c3bb06f7a127cda000005`))
|
|
|
|
sres, err = index.Search(sreq)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if sres.Total != 1 {
|
|
|
|
t.Errorf("expected 1 result, got %d", sres.Total)
|
|
|
|
}
|
|
|
|
if sres.Hits[0].ID != "b" {
|
|
|
|
t.Errorf("expecated id 'b', got '%s'", sres.Hits[0].ID)
|
|
|
|
}
|
|
|
|
|
2015-05-21 13:49:41 +02:00
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
2015-07-31 17:16:11 +02:00
|
|
|
|
|
|
|
func TestTermVectorArrayPositions(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
index, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// index a document with an array of strings
|
|
|
|
err = index.Index("k", struct {
|
|
|
|
Messages []string
|
|
|
|
}{
|
|
|
|
Messages: []string{
|
|
|
|
"first",
|
|
|
|
"second",
|
|
|
|
"third",
|
|
|
|
"last",
|
|
|
|
},
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// search for this document in all field
|
|
|
|
tq := NewTermQuery("second")
|
|
|
|
tsr := NewSearchRequest(tq)
|
|
|
|
results, err := index.Search(tsr)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if results.Total != 1 {
|
|
|
|
t.Fatalf("expected 1 result, got %d", results.Total)
|
|
|
|
}
|
|
|
|
if len(results.Hits[0].Locations["Messages"]["second"]) < 1 {
|
|
|
|
t.Fatalf("expected at least one location")
|
|
|
|
}
|
|
|
|
if len(results.Hits[0].Locations["Messages"]["second"][0].ArrayPositions) < 1 {
|
|
|
|
t.Fatalf("expected at least one location array position")
|
|
|
|
}
|
|
|
|
if results.Hits[0].Locations["Messages"]["second"][0].ArrayPositions[0] != 1 {
|
|
|
|
t.Fatalf("expected array position 1, got %f", results.Hits[0].Locations["Messages"]["second"][0].ArrayPositions[0])
|
|
|
|
}
|
|
|
|
|
|
|
|
// repeat search for this document in Messages field
|
|
|
|
tq2 := NewTermQuery("third").SetField("Messages")
|
|
|
|
tsr = NewSearchRequest(tq2)
|
|
|
|
results, err = index.Search(tsr)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if results.Total != 1 {
|
|
|
|
t.Fatalf("expected 1 result, got %d", results.Total)
|
|
|
|
}
|
|
|
|
if len(results.Hits[0].Locations["Messages"]["third"]) < 1 {
|
|
|
|
t.Fatalf("expected at least one location")
|
|
|
|
}
|
|
|
|
if len(results.Hits[0].Locations["Messages"]["third"][0].ArrayPositions) < 1 {
|
|
|
|
t.Fatalf("expected at least one location array position")
|
|
|
|
}
|
|
|
|
if results.Hits[0].Locations["Messages"]["third"][0].ArrayPositions[0] != 2 {
|
|
|
|
t.Fatalf("expected array position 2, got %f", results.Hits[0].Locations["Messages"]["third"][0].ArrayPositions[0])
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
2015-09-28 23:00:08 +02:00
|
|
|
|
2015-09-22 19:40:20 +02:00
|
|
|
func TestDocumentStaticMapping(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
m := NewIndexMapping()
|
|
|
|
m.DefaultMapping = NewDocumentStaticMapping()
|
|
|
|
m.DefaultMapping.AddFieldMappingsAt("Text", NewTextFieldMapping())
|
|
|
|
m.DefaultMapping.AddFieldMappingsAt("Date", NewDateTimeFieldMapping())
|
|
|
|
m.DefaultMapping.AddFieldMappingsAt("Numeric", NewNumericFieldMapping())
|
|
|
|
|
|
|
|
index, err := New("testidx", m)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
doc1 := struct {
|
|
|
|
Text string
|
|
|
|
IgnoredText string
|
|
|
|
Numeric float64
|
|
|
|
IgnoredNumeric float64
|
|
|
|
Date time.Time
|
|
|
|
IgnoredDate time.Time
|
|
|
|
}{
|
|
|
|
Text: "valid text",
|
|
|
|
IgnoredText: "ignored text",
|
|
|
|
Numeric: 10,
|
|
|
|
IgnoredNumeric: 20,
|
|
|
|
Date: time.Unix(1, 0),
|
|
|
|
IgnoredDate: time.Unix(2, 0),
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.Index("a", doc1)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
fields, err := index.Fields()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
sort.Strings(fields)
|
|
|
|
expectedFields := []string{"Date", "Numeric", "Text", "_all"}
|
|
|
|
if len(fields) != len(expectedFields) {
|
|
|
|
t.Fatalf("invalid field count: %d", len(fields))
|
|
|
|
}
|
|
|
|
for i, expected := range expectedFields {
|
|
|
|
if expected != fields[i] {
|
|
|
|
t.Fatalf("unexpected field[%d]: %s", i, fields[i])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-28 23:00:08 +02:00
|
|
|
func TestIndexEmptyDocId(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
index, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2016-02-09 19:33:11 +01:00
|
|
|
defer func() {
|
|
|
|
err := index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
2015-09-28 23:00:08 +02:00
|
|
|
|
|
|
|
doc := map[string]interface{}{
|
|
|
|
"body": "nodocid",
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.Index("", doc)
|
|
|
|
if err != ErrorEmptyID {
|
|
|
|
t.Errorf("expect index empty doc id to fail")
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.Delete("")
|
|
|
|
if err != ErrorEmptyID {
|
|
|
|
t.Errorf("expect delete empty doc id to fail")
|
|
|
|
}
|
|
|
|
|
|
|
|
batch := index.NewBatch()
|
|
|
|
err = batch.Index("", doc)
|
|
|
|
if err != ErrorEmptyID {
|
|
|
|
t.Errorf("expect index empty doc id in batch to fail")
|
|
|
|
}
|
|
|
|
|
|
|
|
batch.Delete("")
|
|
|
|
if batch.Size() > 0 {
|
|
|
|
t.Errorf("expect delete empty doc id in batch to be ignored")
|
|
|
|
}
|
|
|
|
}
|
2015-11-21 03:15:35 +01:00
|
|
|
|
2015-11-23 14:41:34 +01:00
|
|
|
func TestDateTimeFieldMappingIssue287(t *testing.T) {
|
2015-11-21 03:15:35 +01:00
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
f := NewDateTimeFieldMapping()
|
|
|
|
|
|
|
|
m := NewIndexMapping()
|
|
|
|
m.DefaultMapping = NewDocumentMapping()
|
|
|
|
m.DefaultMapping.AddFieldMappingsAt("Date", f)
|
|
|
|
|
|
|
|
index, err := New("testidx", m)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
type doc struct {
|
|
|
|
Date time.Time
|
|
|
|
}
|
|
|
|
|
|
|
|
now := time.Now()
|
|
|
|
|
|
|
|
// 3hr ago to 1hr ago
|
|
|
|
for i := 0; i < 3; i++ {
|
2015-11-23 18:28:09 +01:00
|
|
|
d := doc{now.Add(time.Duration((i - 3)) * time.Hour)}
|
2015-11-21 03:15:35 +01:00
|
|
|
|
2016-07-01 16:21:41 +02:00
|
|
|
err = index.Index(strconv.FormatInt(int64(i), 10), d)
|
2015-11-21 03:15:35 +01:00
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// search range across all docs
|
2015-11-23 18:28:09 +01:00
|
|
|
start := now.Add(-4 * time.Hour).Format(time.RFC3339)
|
2015-11-21 03:15:35 +01:00
|
|
|
end := now.Format(time.RFC3339)
|
|
|
|
sreq := NewSearchRequest(NewDateRangeQuery(&start, &end))
|
|
|
|
sres, err := index.Search(sreq)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if sres.Total != 3 {
|
|
|
|
t.Errorf("expected 3 results, got %d", sres.Total)
|
|
|
|
}
|
|
|
|
|
|
|
|
// search range includes only oldest
|
2015-11-23 18:28:09 +01:00
|
|
|
start = now.Add(-4 * time.Hour).Format(time.RFC3339)
|
|
|
|
end = now.Add(-121 * time.Minute).Format(time.RFC3339)
|
2015-11-21 03:15:35 +01:00
|
|
|
sreq = NewSearchRequest(NewDateRangeQuery(&start, &end))
|
|
|
|
sres, err = index.Search(sreq)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if sres.Total != 1 {
|
|
|
|
t.Errorf("expected 1 results, got %d", sres.Total)
|
|
|
|
}
|
|
|
|
if sres.Total > 0 && sres.Hits[0].ID != "0" {
|
|
|
|
t.Errorf("expecated id '0', got '%s'", sres.Hits[0].ID)
|
|
|
|
}
|
|
|
|
|
|
|
|
// search range includes only newest
|
2015-11-23 18:28:09 +01:00
|
|
|
start = now.Add(-61 * time.Minute).Format(time.RFC3339)
|
2015-11-21 03:15:35 +01:00
|
|
|
end = now.Format(time.RFC3339)
|
|
|
|
sreq = NewSearchRequest(NewDateRangeQuery(&start, &end))
|
|
|
|
sres, err = index.Search(sreq)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if sres.Total != 1 {
|
|
|
|
t.Errorf("expected 1 results, got %d", sres.Total)
|
|
|
|
}
|
|
|
|
if sres.Total > 0 && sres.Hits[0].ID != "2" {
|
|
|
|
t.Errorf("expecated id '2', got '%s'", sres.Hits[0].ID)
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
2015-12-21 20:59:32 +01:00
|
|
|
|
|
|
|
func TestDocumentFieldArrayPositionsBug295(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
index, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// index a document with an array of strings
|
|
|
|
err = index.Index("k", struct {
|
|
|
|
Messages []string
|
|
|
|
Another string
|
|
|
|
MoreData []string
|
|
|
|
}{
|
|
|
|
Messages: []string{
|
|
|
|
"bleve",
|
|
|
|
"bleve",
|
|
|
|
},
|
|
|
|
Another: "text",
|
|
|
|
MoreData: []string{
|
|
|
|
"a",
|
|
|
|
"b",
|
|
|
|
"c",
|
|
|
|
"bleve",
|
|
|
|
},
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// search for it in the messages field
|
|
|
|
tq := NewTermQuery("bleve").SetField("Messages")
|
|
|
|
tsr := NewSearchRequest(tq)
|
|
|
|
results, err := index.Search(tsr)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if results.Total != 1 {
|
|
|
|
t.Fatalf("expected 1 result, got %d", results.Total)
|
|
|
|
}
|
|
|
|
if len(results.Hits[0].Locations["Messages"]["bleve"]) != 2 {
|
|
|
|
t.Fatalf("expected 2 locations of 'bleve', got %d", len(results.Hits[0].Locations["Messages"]["bleve"]))
|
|
|
|
}
|
|
|
|
if results.Hits[0].Locations["Messages"]["bleve"][0].ArrayPositions[0] != 0 {
|
|
|
|
t.Errorf("expected array position to be 0")
|
|
|
|
}
|
|
|
|
if results.Hits[0].Locations["Messages"]["bleve"][1].ArrayPositions[0] != 1 {
|
|
|
|
t.Errorf("expected array position to be 1")
|
|
|
|
}
|
|
|
|
|
|
|
|
// search for it in all
|
|
|
|
tq = NewTermQuery("bleve")
|
|
|
|
tsr = NewSearchRequest(tq)
|
|
|
|
results, err = index.Search(tsr)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if results.Total != 1 {
|
|
|
|
t.Fatalf("expected 1 result, got %d", results.Total)
|
|
|
|
}
|
|
|
|
if len(results.Hits[0].Locations["Messages"]["bleve"]) != 2 {
|
|
|
|
t.Fatalf("expected 2 locations of 'bleve', got %d", len(results.Hits[0].Locations["Messages"]["bleve"]))
|
|
|
|
}
|
|
|
|
if results.Hits[0].Locations["Messages"]["bleve"][0].ArrayPositions[0] != 0 {
|
|
|
|
t.Errorf("expected array position to be 0")
|
|
|
|
}
|
|
|
|
if results.Hits[0].Locations["Messages"]["bleve"][1].ArrayPositions[0] != 1 {
|
|
|
|
t.Errorf("expected array position to be 1")
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
2016-01-12 02:18:03 +01:00
|
|
|
|
|
|
|
func TestBooleanFieldMappingIssue109(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
m := NewIndexMapping()
|
|
|
|
m.DefaultMapping = NewDocumentMapping()
|
|
|
|
m.DefaultMapping.AddFieldMappingsAt("Bool", NewBooleanFieldMapping())
|
|
|
|
|
|
|
|
index, err := New("testidx", m)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
type doc struct {
|
|
|
|
Bool bool
|
|
|
|
}
|
2016-01-13 23:10:13 +01:00
|
|
|
err = index.Index("true", &doc{Bool: true})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
err = index.Index("false", &doc{Bool: false})
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2016-01-12 02:18:03 +01:00
|
|
|
|
|
|
|
sreq := NewSearchRequest(NewBoolFieldQuery(true).SetField("Bool"))
|
|
|
|
sres, err := index.Search(sreq)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if sres.Total != 1 {
|
|
|
|
t.Errorf("expected 1 results, got %d", sres.Total)
|
|
|
|
}
|
|
|
|
|
|
|
|
sreq = NewSearchRequest(NewBoolFieldQuery(false).SetField("Bool"))
|
|
|
|
sres, err = index.Search(sreq)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if sres.Total != 1 {
|
|
|
|
t.Errorf("expected 1 results, got %d", sres.Total)
|
|
|
|
}
|
|
|
|
|
|
|
|
sreq = NewSearchRequest(NewBoolFieldQuery(true))
|
|
|
|
sres, err = index.Search(sreq)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if sres.Total != 1 {
|
|
|
|
t.Errorf("expected 1 results, got %d", sres.Total)
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
2016-03-02 22:55:02 +01:00
|
|
|
|
|
|
|
func TestSearchTimeout(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
index, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
defer func() {
|
|
|
|
err := index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
// first run a search with an absurdly long timeout (should succeeed)
|
|
|
|
ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
|
|
|
|
query := NewTermQuery("water")
|
|
|
|
req := NewSearchRequest(query)
|
|
|
|
_, err = index.SearchInContext(ctx, req)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// now run a search again with an absurdly low timeout (should timeout)
|
|
|
|
ctx, _ = context.WithTimeout(context.Background(), 1*time.Microsecond)
|
|
|
|
sq := &slowQuery{
|
|
|
|
actual: query,
|
|
|
|
delay: 50 * time.Millisecond, // on Windows timer resolution is 15ms
|
|
|
|
}
|
|
|
|
req.Query = sq
|
|
|
|
_, err = index.SearchInContext(ctx, req)
|
|
|
|
if err != context.DeadlineExceeded {
|
|
|
|
t.Fatalf("exected %v, got: %v", context.DeadlineExceeded, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// now run a search with a long timeout, but with a long query, and cancel it
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
|
|
sq = &slowQuery{
|
|
|
|
actual: query,
|
|
|
|
delay: 100 * time.Millisecond, // on Windows timer resolution is 15ms
|
|
|
|
}
|
|
|
|
req = NewSearchRequest(sq)
|
|
|
|
cancel()
|
|
|
|
_, err = index.SearchInContext(ctx, req)
|
|
|
|
if err != context.Canceled {
|
|
|
|
t.Fatalf("exected %v, got: %v", context.Canceled, err)
|
|
|
|
}
|
|
|
|
}
|
2016-03-07 22:05:34 +01:00
|
|
|
|
|
|
|
// TestConfigCache exposes a concurrent map write with go 1.6
|
|
|
|
func TestConfigCache(t *testing.T) {
|
|
|
|
for i := 0; i < 100; i++ {
|
|
|
|
go func() {
|
|
|
|
_, err := Config.Cache.HighlighterNamed(Config.DefaultHighlighter)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
}
|
2016-04-08 21:32:13 +02:00
|
|
|
|
|
|
|
func TestBatchRaceBug260(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
i, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
b := i.NewBatch()
|
|
|
|
err = b.Index("1", 1)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
err = i.Batch(b)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
b.Reset()
|
|
|
|
err = b.Index("2", 2)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
err = i.Batch(b)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
b.Reset()
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkBatchOverhead(b *testing.B) {
|
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
m := NewIndexMapping()
|
|
|
|
i, err := NewUsing("testidx", m, Config.DefaultIndexType, null.Name, nil)
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
for n := 0; n < b.N; n++ {
|
|
|
|
// put 1000 items in a batch
|
|
|
|
batch := i.NewBatch()
|
|
|
|
for i := 0; i < 1000; i++ {
|
|
|
|
err = batch.Index(fmt.Sprintf("%d", i), map[string]interface{}{"name": "bleve"})
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
err = i.Batch(batch)
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
batch.Reset()
|
|
|
|
}
|
|
|
|
}
|
2016-08-06 16:47:34 +02:00
|
|
|
|
|
|
|
func TestOpenReadonlyMultiple(t *testing.T) {
|
|
|
|
defer func() {
|
|
|
|
err := os.RemoveAll("testidx")
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
// build an index and close it
|
|
|
|
index, err := New("testidx", NewIndexMapping())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
doca := map[string]interface{}{
|
|
|
|
"name": "marty",
|
|
|
|
"desc": "gophercon india",
|
|
|
|
}
|
|
|
|
err = index.Index("a", doca)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// now open it read-only
|
|
|
|
index, err = OpenUsing("testidx", map[string]interface{}{
|
|
|
|
"read_only": true,
|
|
|
|
})
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// now open it again
|
|
|
|
index2, err := OpenUsing("testidx", map[string]interface{}{
|
|
|
|
"read_only": true,
|
|
|
|
})
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
err = index.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
err = index2.Close()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
2016-08-31 21:21:44 +02:00
|
|
|
|
|
|
|
// TestBug408 tests for VERY large values of size, even though actual result
|
|
|
|
// set may be reasonable size
|
|
|
|
func TestBug408(t *testing.T) {
|
|
|
|
type TestStruct struct {
|
|
|
|
ID string `json:"id"`
|
|
|
|
UserID *string `json:"user_id"`
|
|
|
|
}
|
|
|
|
|
|
|
|
docMapping := NewDocumentMapping()
|
|
|
|
docMapping.AddFieldMappingsAt("id", NewTextFieldMapping())
|
|
|
|
docMapping.AddFieldMappingsAt("user_id", NewTextFieldMapping())
|
|
|
|
|
|
|
|
indexMapping := NewIndexMapping()
|
|
|
|
indexMapping.DefaultMapping = docMapping
|
|
|
|
|
|
|
|
index, err := New("", indexMapping)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
numToTest := 10
|
|
|
|
matchUserID := "match"
|
|
|
|
noMatchUserID := "no_match"
|
|
|
|
matchingDocIds := make(map[string]struct{})
|
|
|
|
|
|
|
|
for i := 0; i < numToTest; i++ {
|
|
|
|
ds := &TestStruct{"id_" + strconv.Itoa(i), nil}
|
|
|
|
if i%2 == 0 {
|
|
|
|
ds.UserID = &noMatchUserID
|
|
|
|
} else {
|
|
|
|
ds.UserID = &matchUserID
|
|
|
|
matchingDocIds[ds.ID] = struct{}{}
|
|
|
|
}
|
|
|
|
err = index.Index(ds.ID, ds)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
cnt, err := index.DocCount()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if int(cnt) != numToTest {
|
|
|
|
t.Fatalf("expected %d documents in index, got %d", numToTest, cnt)
|
|
|
|
}
|
|
|
|
|
|
|
|
q := NewTermQuery(matchUserID).SetField("user_id")
|
|
|
|
searchReq := NewSearchRequestOptions(q, math.MaxInt32, 0, false)
|
|
|
|
results, err := index.Search(searchReq)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if int(results.Total) != numToTest/2 {
|
|
|
|
t.Fatalf("expected %d search hits, got %d", numToTest/2, results.Total)
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, result := range results.Hits {
|
|
|
|
if _, found := matchingDocIds[result.ID]; !found {
|
|
|
|
t.Fatalf("document with ID %s not in results as expected", result.ID)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|