// 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 bleve

import (

"context"

"encoding/json"

"fmt"

"math"

"math/rand"

"os"

"reflect"

"sort"

"strconv"

"strings"

"testing"

"time"

"github.com/blevesearch/bleve/v2/analysis"

"github.com/blevesearch/bleve/v2/analysis/analyzer/custom"

"github.com/blevesearch/bleve/v2/analysis/analyzer/keyword"

"github.com/blevesearch/bleve/v2/analysis/analyzer/simple"

"github.com/blevesearch/bleve/v2/analysis/analyzer/standard"

html_char_filter "github.com/blevesearch/bleve/v2/analysis/char/html"

regexp_char_filter "github.com/blevesearch/bleve/v2/analysis/char/regexp"

"github.com/blevesearch/bleve/v2/analysis/datetime/flexible"

"github.com/blevesearch/bleve/v2/analysis/datetime/iso"

"github.com/blevesearch/bleve/v2/analysis/datetime/percent"

"github.com/blevesearch/bleve/v2/analysis/datetime/sanitized"

"github.com/blevesearch/bleve/v2/analysis/datetime/timestamp/microseconds"

"github.com/blevesearch/bleve/v2/analysis/datetime/timestamp/milliseconds"

"github.com/blevesearch/bleve/v2/analysis/datetime/timestamp/nanoseconds"

"github.com/blevesearch/bleve/v2/analysis/datetime/timestamp/seconds"

"github.com/blevesearch/bleve/v2/analysis/lang/en"

"github.com/blevesearch/bleve/v2/analysis/token/length"

"github.com/blevesearch/bleve/v2/analysis/token/lowercase"

"github.com/blevesearch/bleve/v2/analysis/token/shingle"

"github.com/blevesearch/bleve/v2/analysis/tokenizer/single"

"github.com/blevesearch/bleve/v2/analysis/tokenizer/whitespace"

"github.com/blevesearch/bleve/v2/document"

"github.com/blevesearch/bleve/v2/geo"

"github.com/blevesearch/bleve/v2/index/scorch"

"github.com/blevesearch/bleve/v2/index/upsidedown"

"github.com/blevesearch/bleve/v2/mapping"

"github.com/blevesearch/bleve/v2/search"

"github.com/blevesearch/bleve/v2/search/highlight/highlighter/ansi"

"github.com/blevesearch/bleve/v2/search/highlight/highlighter/html"

"github.com/blevesearch/bleve/v2/search/query"

index "github.com/blevesearch/bleve_index_api"

)

func TestSortedFacetedQuery(t *testing.T) {

tmpIndexPath := createTmpIndexPath(t)

defer cleanupTmpIndexPath(t, tmpIndexPath)

indexMapping := NewIndexMapping()

indexMapping.TypeField = "type"

indexMapping.DefaultAnalyzer = "en"

documentMapping := NewDocumentMapping()

indexMapping.AddDocumentMapping("hotel", documentMapping)

contentFieldMapping := NewTextFieldMapping()

contentFieldMapping.Index = true

contentFieldMapping.DocValues = true

documentMapping.AddFieldMappingsAt("content", contentFieldMapping)

documentMapping.AddFieldMappingsAt("country", contentFieldMapping)

index, err := New(tmpIndexPath, indexMapping)

if err != nil {

t.Fatal(err)

}

defer func() {

err := index.Close()

if err != nil {

t.Fatal(err)

}

}()

if err := index.Index("1", map[string]interface{}{

"country": "india",

"content": "k",

}); err != nil {

t.Fatal(err)

}

if err := index.Index("2", map[string]interface{}{

"country": "india",

"content": "l",

}); err != nil {

t.Fatal(err)

}

if err := index.Index("3", map[string]interface{}{

"country": "india",

"content": "k",

}); err != nil {

t.Fatal(err)

}

d, err := index.DocCount()

if err != nil {

t.Fatal(err)

}

if d != 3 {

t.Errorf("expected 3, got %d", d)

}

query := NewMatchPhraseQuery("india")

query.SetField("country")

searchRequest := NewSearchRequest(query)

searchRequest.SortBy([]string{"content"})

fr := NewFacetRequest("content", 100)

searchRequest.AddFacet("content_facet", fr)

searchResults, err := index.Search(searchRequest)

if err != nil {

t.Fatal(err)

}

expectedResults := map[string]int{"k": 2, "l": 1}

for _, v := range searchResults.Facets {

for _, v1 := range v.Terms.Terms() {

if v1.Count != expectedResults[v1.Term] {

t.Errorf("expected %d, got %d", expectedResults[v1.Term], v1.Count)

}

}

}

}

func TestMatchAllScorer(t *testing.T) {

tmpIndexPath := createTmpIndexPath(t)

defer cleanupTmpIndexPath(t, tmpIndexPath)

indexMapping := NewIndexMapping()

indexMapping.TypeField = "type"

indexMapping.DefaultAnalyzer = "en"

documentMapping := NewDocumentMapping()

contentFieldMapping := NewTextFieldMapping()

contentFieldMapping.Index = true

contentFieldMapping.Store = true

documentMapping.AddFieldMappingsAt("content", contentFieldMapping)

index, err := New(tmpIndexPath, indexMapping)

if err != nil {

t.Fatal(err)

}

defer func() {

err := index.Close()

if err != nil {

t.Fatal(err)

}

}()

if err := index.Index("1", map[string]interface{}{

"country": "india",

"content": "k",

}); err != nil {

t.Fatal(err)

}

if err := index.Index("2", map[string]interface{}{

"country": "india",

"content": "l",

}); err != nil {

t.Fatal(err)

}

if err := index.Index("3", map[string]interface{}{

"country": "india",

"content": "k",

}); err != nil {

t.Fatal(err)

}

d, err := index.DocCount()

if err != nil {

t.Fatal(err)

}

if d != 3 {

t.Errorf("expected 3, got %d", d)

}

searchRequest := NewSearchRequest(NewMatchAllQuery())

searchRequest.Score = "none"

searchResults, err := index.Search(searchRequest)

if err != nil {

t.Fatal(err)

}

if searchResults.Total != 3 {

t.Fatalf("expected all the 3 docs in the index, got %v", searchResults.Total)

}

for _, hit := range searchResults.Hits {

if hit.Score != 0.0 {

t.Fatalf("expected 0 score since score = none, got %v", hit.Score)

}

}

}

func TestSearchResultString(t *testing.T) {

tests := []struct {

result *SearchResult

str string

}{

{

result: &SearchResult{

Request: &SearchRequest{

Size: 10,

},

Total: 5,

Took: 1 * time.Second,

Hits: search.DocumentMatchCollection{

&search.DocumentMatch{},

&search.DocumentMatch{},

&search.DocumentMatch{},

&search.DocumentMatch{},

&search.DocumentMatch{},

},

},

str: "5 matches, showing 1 through 5, took 1s",

},

{

result: &SearchResult{

Request: &SearchRequest{

Size: 0,

},

Total: 5,

Hits: search.DocumentMatchCollection{},

},

str: "5 matches",

},

{

result: &SearchResult{

Request: &SearchRequest{

Size: 10,

},

Total: 0,

Hits: search.DocumentMatchCollection{},

},

str: "No matches",

},

// no search request

{

result: &SearchResult{

Total: 3,

Took: 500 * time.Millisecond,

Hits: search.DocumentMatchCollection{

&search.DocumentMatch{},

&search.DocumentMatch{},

&search.DocumentMatch{},

},

},

str: "3 matches, took 500ms",

},

}

for _, test := range tests {

srstring := test.result.String()

if !strings.HasPrefix(srstring, test.str) {

t.Errorf("expected to start %s, got %s", test.str, srstring)

}

}

}

func TestSearchResultMerge(t *testing.T) {

l := &SearchResult{

Status: &SearchStatus{

Total: 1,

Successful: 1,

Errors: make(map[string]error),

},

Total: 1,

MaxScore: 1,

Hits: search.DocumentMatchCollection{

&search.DocumentMatch{

ID: "a",

Score: 1,

},

},

}

r := &SearchResult{

Status: &SearchStatus{

Total: 1,

Successful: 1,

Errors: make(map[string]error),

},

Total: 1,

MaxScore: 2,

Hits: search.DocumentMatchCollection{

&search.DocumentMatch{

ID: "b",

Score: 2,

},

},

}

expected := &SearchResult{

Status: &SearchStatus{

Total: 2,

Successful: 2,

Errors: make(map[string]error),

},

Total: 2,

MaxScore: 2,

Hits: search.DocumentMatchCollection{

&search.DocumentMatch{

ID: "a",

Score: 1,

},

&search.DocumentMatch{

ID: "b",

Score: 2,

},

},

}

l.Merge(r)

if !reflect.DeepEqual(l, expected) {

t.Errorf("expected %#v, got %#v", expected, l)

}

}

func TestUnmarshalingSearchResult(t *testing.T) {

searchResponse := []byte(`{

"status":{

"total":1,

"failed":1,

"successful":0,

"errors":{

"default_index_362ce020b3d62b13_348f5c3c":"context deadline exceeded"

}

},

"request":{

"query":{

"match":"emp",

"field":"type",

"boost":1,

"prefix_length":0,

"fuzziness":0

},

"size":10000000,

"from":0,

"highlight":null,

"fields":[],

"facets":null,

"explain":false

},

"hits":null,

"total_hits":0,

"max_score":0,

"took":0,

"facets":null

}`)

rv := &SearchResult{

Status: &SearchStatus{

Errors: make(map[string]error),

},

}

err = json.Unmarshal(searchResponse, rv)

if err != nil {

t.Error(err)

}

if len(rv.Status.Errors) != 1 {

t.Errorf("expected 1 error, got %d", len(rv.Status.Errors))

}

}

func TestFacetNumericDateRangeRequests(t *testing.T) {

drMissingErr := fmt.Errorf("date range query must specify either start, end or both for range name 'testName'")

nrMissingErr := fmt.Errorf("numeric range query must specify either min, max or both for range name 'testName'")

drNrErr := fmt.Errorf("facet can only contain numeric ranges or date ranges, not both")

drNameDupErr := fmt.Errorf("date ranges contains duplicate name 'testName'")

nrNameDupErr := fmt.Errorf("numeric ranges contains duplicate name 'testName'")

value := float64(5)

tests := []struct {

facet *FacetRequest

result error

}{

{

facet: &FacetRequest{

Field: "Date_Range_Success_With_StartEnd",

Size: 1,

DateTimeRanges: []*dateTimeRange{

{Name: "testName", Start: time.Unix(0, 0), End: time.Now()},

},

},

result: nil,

},

{

facet: &FacetRequest{

Field: "Date_Range_Success_With_Start",

Size: 1,

DateTimeRanges: []*dateTimeRange{

{Name: "testName", Start: time.Unix(0, 0)},

},

},

result: nil,

},

{

facet: &FacetRequest{

Field: "Date_Range_Success_With_End",

Size: 1,

DateTimeRanges: []*dateTimeRange{

{Name: "testName", End: time.Now()},

},

},

result: nil,

},

{

facet: &FacetRequest{

Field: "Numeric_Range_Success_With_MinMax",

Size: 1,

NumericRanges: []*numericRange{

{Name: "testName", Min: &value, Max: &value},

},

},

result: nil,

},

{

facet: &FacetRequest{

Field: "Numeric_Range_Success_With_Min",

Size: 1,

NumericRanges: []*numericRange{

{Name: "testName", Min: &value},

},

},

result: nil,

},

{

facet: &FacetRequest{

Field: "Numeric_Range_Success_With_Max",

Size: 1,

NumericRanges: []*numericRange{

{Name: "testName", Max: &value},

},

},

result: nil,

},

{

facet: &FacetRequest{

Field: "Date_Range_Missing_Failure",

Size: 1,

DateTimeRanges: []*dateTimeRange{

{Name: "testName2", Start: time.Unix(0, 0)},

{Name: "testName1", End: time.Now()},

{Name: "testName"},

},

},

result: drMissingErr,

},

{

facet: &FacetRequest{

Field: "Numeric_Range_Missing_Failure",

Size: 1,

NumericRanges: []*numericRange{

{Name: "testName2", Min: &value},

{Name: "testName1", Max: &value},

{Name: "testName"},

},

},

result: nrMissingErr,

},

{

facet: &FacetRequest{

Field: "Numeric_And_DateRanges_Failure",

Size: 1,

NumericRanges: []*numericRange{

{Name: "testName", Max: &value},

},

DateTimeRanges: []*dateTimeRange{

{Name: "testName", End: time.Now()},

},

},

result: drNrErr,

},

{

facet: &FacetRequest{

Field: "Numeric_Range_Name_Repeat_Failure",

Size: 1,

NumericRanges: []*numericRange{

{Name: "testName", Min: &value},

{Name: "testName", Max: &value},

},

},

result: nrNameDupErr,

},

{

facet: &FacetRequest{

Field: "Date_Range_Name_Repeat_Failure",

Size: 1,

DateTimeRanges: []*dateTimeRange{

{Name: "testName", Start: time.Unix(0, 0)},

{Name: "testName", End: time.Now()},

},

},

result: drNameDupErr,

},

}

for _, test := range tests {

result := test.facet.Validate()

if !reflect.DeepEqual(result, test.result) {

t.Errorf("expected %#v, got %#v", test.result, result)

}

}

}

func TestSearchResultFacetsMerge(t *testing.T) {

lowmed := "2010-01-01"

medhi := "2011-01-01"

hihigher := "2012-01-01"

fr := &search.FacetResult{

Field: "birthday",

Total: 100,

Missing: 25,

Other: 25,

DateRanges: []*search.DateRangeFacet{

{

Name: "low",

End: &lowmed,

Count: 25,

},

{

Name: "med",

Count: 24,

Start: &lowmed,

End: &medhi,

},

{

Name: "hi",

Count: 1,

Start: &medhi,

End: &hihigher,

},

},

}

frs := search.FacetResults{

"birthdays": fr,

}

l := &SearchResult{

Status: &SearchStatus{

Total: 10,

Successful: 1,

Errors: make(map[string]error),

},

Total: 10,

MaxScore: 1,

}

r := &SearchResult{

Status: &SearchStatus{

Total: 1,

Successful: 1,

Errors: make(map[string]error),

},

Total: 1,

MaxScore: 2,

Facets: frs,

}

expected := &SearchResult{

Status: &SearchStatus{

Total: 11,

Successful: 2,

Errors: make(map[string]error),

},

Total: 11,

MaxScore: 2,

Facets: frs,

}

l.Merge(r)

if !reflect.DeepEqual(l, expected) {

t.Errorf("expected %#v, got %#v", expected, l)

}

}

func TestMemoryNeededForSearchResult(t *testing.T) {

query := NewTermQuery("blah")

req := NewSearchRequest(query)

var sr SearchResult

expect := sr.Size()

var dm search.DocumentMatch

expect += 10 * dm.Size()

estimate := MemoryNeededForSearchResult(req)

if estimate != uint64(expect) {

t.Errorf("estimate not what is expected: %v != %v", estimate, expect)

}

}

// https://github.com/blevesearch/bleve/issues/954

func TestNestedBooleanSearchers(t *testing.T) {

// create an index with a custom analyzer

idxMapping := NewIndexMapping()

if err := idxMapping.AddCustomAnalyzer("3xbla", map[string]interface{}{

"type": custom.Name,

"tokenizer": whitespace.Name,

"token_filters": []interface{}{lowercase.Name, "stop_en"},

}); err != nil {

t.Fatal(err)

}

idxMapping.DefaultAnalyzer = "3xbla"

tmpIndexPath := createTmpIndexPath(t)

defer cleanupTmpIndexPath(t, tmpIndexPath)

idx, err := New(tmpIndexPath, idxMapping)

if err != nil {

t.Fatal(err)

}

defer func() {

err = idx.Close()

if err != nil {

t.Fatal(err)

}

}()

// create and insert documents as a batch

batch := idx.NewBatch()

matches := 0

for i := 0; i < 100; i++ {

hostname := fmt.Sprintf("planner_hostname_%d", i%5)

metadata := map[string]string{"region": fmt.Sprintf("planner_us-east-%d", i%5)}

// Expected matches

if (hostname == "planner_hostname_1" || hostname == "planner_hostname_2") &&

metadata["region"] == "planner_us-east-1" {

matches++

}

doc := document.NewDocument(strconv.Itoa(i))

doc.Fields = []document.Field{

document.NewTextFieldCustom("hostname", []uint64{}, []byte(hostname),

index.IndexField,

&analysis.DefaultAnalyzer{

Tokenizer: single.NewSingleTokenTokenizer(),

TokenFilters: []analysis.TokenFilter{

lowercase.NewLowerCaseFilter(),

},

},

),

}

for k, v := range metadata {

doc.AddField(document.NewTextFieldWithIndexingOptions(

fmt.Sprintf("metadata.%s", k), []uint64{}, []byte(v), index.IndexField))

}

doc.CompositeFields = []*document.CompositeField{

document.NewCompositeFieldWithIndexingOptions(

"_all", true, []string{"text"}, []string{},

index.IndexField|index.IncludeTermVectors),

}

if err = batch.IndexAdvanced(doc); err != nil {

t.Fatal(err)

}

}

if err = idx.Batch(batch); err != nil {

t.Fatal(err)

}

que, err := query.ParseQuery([]byte(

`{

"conjuncts": [

{

"must": {

"conjuncts": [

{

"disjuncts": [

{

"match": "planner_hostname_1",

"field": "hostname"

},

{

"match": "planner_hostname_2",

"field": "hostname"

}

]

}

]

}

},

{

"must": {

"conjuncts": [

{

"match": "planner_us-east-1",

"field": "metadata.region"

}

]

}

}

]

}`,

))

if err != nil {

t.Fatal(err)

}

req := NewSearchRequest(que)

req.Size = 100

req.Fields = []string{"hostname", "metadata.region"}

searchResults, err := idx.Search(req)

if err != nil {

t.Fatal(err)

}

if matches != len(searchResults.Hits) {

t.Fatalf("Unexpected result set, %v != %v", matches, len(searchResults.Hits))

}

}

func TestNestedBooleanMustNotSearcherUpsidedown(t *testing.T) {

tmpIndexPath := createTmpIndexPath(t)

defer cleanupTmpIndexPath(t, tmpIndexPath)

// create an index with default settings

idxMapping := NewIndexMapping()

idx, err := New(tmpIndexPath, idxMapping)

if err != nil {

t.Fatal(err)

}

defer func() {

err = idx.Close()

if err != nil {

t.Fatal(err)

}

}()

// create and insert documents as a batch

batch := idx.NewBatch()

docs := []struct {

id string

hasRole bool

investigationId string

}{

{

id: "1@1",

hasRole: true,

investigationId: "1",

},

{

id: "1@2",

hasRole: false,

investigationId: "2",

},

{

id: "2@1",

hasRole: true,

investigationId: "1",

},

{

id: "2@2",

hasRole: false,

investigationId: "2",

},

{

id: "3@1",

hasRole: true,

investigationId: "1",

},

{

id: "3@2",

hasRole: false,

investigationId: "2",

},

{

id: "4@1",

hasRole: true,

investigationId: "1",

},

{

id: "5@1",

hasRole: true,

investigationId: "1",

},

{

id: "6@1",

hasRole: true,

investigationId: "1",

},

{

id: "7@1",

hasRole: true,

investigationId: "1",

},

}

for i := 0; i < len(docs); i++ {

doc := document.NewDocument(docs[i].id)

doc.Fields = []document.Field{

document.NewTextField("id", []uint64{}, []byte(docs[i].id)),

document.NewBooleanField("hasRole", []uint64{}, docs[i].hasRole),

document.NewTextField("investigationId", []uint64{}, []byte(docs[i].investigationId)),

}

doc.CompositeFields = []*document.CompositeField{

document.NewCompositeFieldWithIndexingOptions(

"_all", true, []string{"text"}, []string{},

index.IndexField|index.IncludeTermVectors),

}

if err = batch.IndexAdvanced(doc); err != nil {

t.Fatal(err)

}

}

if err = idx.Batch(batch); err != nil {

t.Fatal(err)

}

tq := NewTermQuery("1")

tq.SetField("investigationId")

// using must not, for cases that the field did not exists at all

hasRole := NewBoolFieldQuery(true)

hasRole.SetField("hasRole")

noRole := NewBooleanQuery()

noRole.AddMustNot(hasRole)

oneRolesOrNoRoles := NewBooleanQuery()

oneRolesOrNoRoles.AddShould(noRole)

oneRolesOrNoRoles.SetMinShould(1)

q := NewConjunctionQuery(tq, oneRolesOrNoRoles)

sr := NewSearchRequestOptions(q, 100, 0, false)

sr.Fields = []string{"hasRole"}

sr.Highlight = NewHighlight()

res, err := idx.Search(sr)

if err != nil {

t.Fatal(err)

}

if res.Total != 0 {

t.Fatalf("Unexpected result, %v != 0", res.Total)

}

}

func TestSearchScorchOverEmptyKeyword(t *testing.T) {

defaultIndexType := Config.DefaultIndexType

Config.DefaultIndexType = scorch.Name

dmap := mapping.NewDocumentMapping()

dmap.DefaultAnalyzer = standard.Name

fm := mapping.NewTextFieldMapping()

fm.Analyzer = keyword.Name

fm1 := mapping.NewTextFieldMapping()

fm1.Analyzer = standard.Name

dmap.AddFieldMappingsAt("id", fm)

dmap.AddFieldMappingsAt("name", fm1)

imap := mapping.NewIndexMapping()

imap.DefaultMapping = dmap

imap.DefaultAnalyzer = standard.Name

tmpIndexPath := createTmpIndexPath(t)

defer cleanupTmpIndexPath(t, tmpIndexPath)

idx, err := New(tmpIndexPath, imap)

if err != nil {

t.Fatal(err)

}

defer func() {

err = idx.Close()

if err != nil {

t.Fatal(err)

}

Config.DefaultIndexType = defaultIndexType

}()

for i := 0; i < 10; i++ {

err = idx.Index(fmt.Sprint(i), map[string]string{"name": fmt.Sprintf("test%d", i), "id": ""})

if err != nil {

t.Fatal(err)

}

}

count, err := idx.DocCount()

if err != nil {

t.Fatal(err)

}

if count != 10 {

t.Fatalf("Unexpected doc count: %v, expected 10", count)

}

q := query.NewWildcardQuery("test*")

sr := NewSearchRequestOptions(q, 40, 0, false)

res, err := idx.Search(sr)

if err != nil {

t.Fatal(err)

}

if res.Total != 10 {

t.Fatalf("Unexpected search hits: %v, expected 10", res.Total)

}

}

func TestMultipleNestedBooleanMustNotSearchersOnScorch(t *testing.T) {

defaultIndexType := Config.DefaultIndexType

Config.DefaultIndexType = scorch.Name

tmpIndexPath := createTmpIndexPath(t)

defer cleanupTmpIndexPath(t, tmpIndexPath)

// create an index with default settings

idxMapping := NewIndexMapping()

idx, err := New(tmpIndexPath, idxMapping)

if err != nil {

t.Fatal(err)

}

defer func() {

err = idx.Close()

if err != nil {

t.Fatal(err)

}

Config.DefaultIndexType = defaultIndexType

}()

// create and insert documents as a batch

batch := idx.NewBatch()

doc := document.NewDocument("1-child-0")

doc.Fields = []document.Field{

document.NewTextField("id", []uint64{}, []byte("1-child-0")),

document.NewBooleanField("hasRole", []uint64{}, false),

document.NewTextField("roles", []uint64{}, []byte("R1")),

document.NewNumericField("type", []uint64{}, 0),

}

doc.CompositeFields = []*document.CompositeField{

document.NewCompositeFieldWithIndexingOptions(

"_all", true, []string{"text"}, []string{},

index.IndexField|index.IncludeTermVectors),

}

if err = batch.IndexAdvanced(doc); err != nil {

t.Fatal(err)

}

docs := []struct {

id string

hasRole bool

typ int

}{

{

id: "16d6fa37-48fd-4dea-8b3d-a52bddf73951",

hasRole: false,

typ: 9,

},

{

id: "18fa9eb2-8b1f-46f0-8b56-b4c551213f78",

hasRole: false,

typ: 9,

},

{

id: "3085855b-d74b-474a-86c3-9bf3e4504382",

hasRole: false,

typ: 9,

},

{

id: "38ef5d28-0f85-4fb0-8a94-dd20751c3364",

hasRole: false,

typ: 9,

},

}

for i := 0; i < len(docs); i++ {

doc := document.NewDocument(docs[i].id)

doc.Fields = []document.Field{