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-29 20:18:36 +02:00
|
|
|
|
2014-07-30 18:30:38 +02:00
|
|
|
package bleve
|
|
|
|
|
|
|
|
import (
|
2014-09-03 19:02:10 +02:00
|
|
|
"log"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/blevesearch/bleve/analysis"
|
2014-08-28 21:38:57 +02:00
|
|
|
"github.com/blevesearch/bleve/document"
|
2014-07-30 18:30:38 +02:00
|
|
|
)
|
|
|
|
|
2014-08-31 16:55:22 +02:00
|
|
|
// A FieldMapping describes how a specific item
|
|
|
|
// should be put into the index.
|
2014-07-30 18:30:38 +02:00
|
|
|
type FieldMapping struct {
|
|
|
|
Name *string `json:"name"`
|
|
|
|
Type *string `json:"type"`
|
|
|
|
Analyzer *string `json:"analyzer"`
|
|
|
|
Store *bool `json:"store"`
|
|
|
|
Index *bool `json:"index"`
|
|
|
|
IncludeTermVectors *bool `json:"include_term_vectors"`
|
|
|
|
IncludeInAll *bool `json:"include_in_all"`
|
2014-08-03 23:21:41 +02:00
|
|
|
DateFormat *string `json:"date_format"`
|
2014-07-30 18:30:38 +02:00
|
|
|
}
|
|
|
|
|
2014-08-31 16:55:22 +02:00
|
|
|
// NewFieldMapping returns a FieldMapping with the
|
|
|
|
// specified behavior.
|
2014-07-30 18:30:38 +02:00
|
|
|
func NewFieldMapping(name, typ, analyzer string, store, index bool, includeTermVectors bool, includeInAll bool) *FieldMapping {
|
|
|
|
return &FieldMapping{
|
|
|
|
Name: &name,
|
|
|
|
Type: &typ,
|
|
|
|
Analyzer: &analyzer,
|
|
|
|
Store: &store,
|
|
|
|
Index: &index,
|
|
|
|
IncludeTermVectors: &includeTermVectors,
|
|
|
|
IncludeInAll: &includeInAll,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-03 19:02:10 +02:00
|
|
|
func defaultNumericFieldMapping() *FieldMapping {
|
|
|
|
typ := "number"
|
|
|
|
store := true
|
|
|
|
index := true
|
|
|
|
return &FieldMapping{
|
|
|
|
Type: &typ,
|
|
|
|
Store: &store,
|
|
|
|
Index: &index,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func defaultDateTimeFieldMapping() *FieldMapping {
|
|
|
|
typ := "datetime"
|
|
|
|
store := true
|
|
|
|
index := true
|
|
|
|
return &FieldMapping{
|
|
|
|
Type: &typ,
|
|
|
|
Store: &store,
|
|
|
|
Index: &index,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func defaultTextFieldMapping() *FieldMapping {
|
|
|
|
typ := "text"
|
|
|
|
store := true
|
|
|
|
index := true
|
|
|
|
include := true
|
|
|
|
return &FieldMapping{
|
|
|
|
Type: &typ,
|
|
|
|
Store: &store,
|
|
|
|
Index: &index,
|
|
|
|
IncludeTermVectors: &include,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-31 16:55:22 +02:00
|
|
|
// Options returns the indexing options for this field.
|
2014-07-30 18:30:38 +02:00
|
|
|
func (fm *FieldMapping) Options() document.IndexingOptions {
|
|
|
|
var rv document.IndexingOptions
|
2014-09-03 19:02:10 +02:00
|
|
|
if fm.Store != nil && *fm.Store {
|
|
|
|
rv |= document.StoreField
|
2014-07-30 18:30:38 +02:00
|
|
|
}
|
2014-09-03 19:02:10 +02:00
|
|
|
if fm.Index != nil && *fm.Index {
|
|
|
|
rv |= document.IndexField
|
2014-07-30 18:30:38 +02:00
|
|
|
}
|
2014-09-03 19:02:10 +02:00
|
|
|
if fm.IncludeTermVectors != nil && *fm.IncludeTermVectors {
|
|
|
|
rv |= document.IncludeTermVectors
|
2014-07-30 18:30:38 +02:00
|
|
|
}
|
|
|
|
return rv
|
|
|
|
}
|
2014-09-03 19:02:10 +02:00
|
|
|
|
|
|
|
func (fm *FieldMapping) processString(propertyValueString string, pathString string, path []string, indexes []uint64, context *walkContext) {
|
|
|
|
fieldName := getFieldName(pathString, path, fm)
|
|
|
|
options := fm.Options()
|
|
|
|
if *fm.Type == "text" {
|
|
|
|
analyzer := fm.analyzerForField(path, context)
|
|
|
|
field := document.NewTextFieldCustom(fieldName, indexes, []byte(propertyValueString), options, analyzer)
|
|
|
|
context.doc.AddField(field)
|
|
|
|
|
|
|
|
if fm.IncludeInAll != nil && !*fm.IncludeInAll {
|
|
|
|
context.excludedFromAll = append(context.excludedFromAll, fieldName)
|
|
|
|
}
|
|
|
|
} else if *fm.Type == "datetime" {
|
|
|
|
dateTimeFormat := context.im.DefaultDateTimeParser
|
|
|
|
if fm.DateFormat != nil {
|
|
|
|
dateTimeFormat = *fm.DateFormat
|
|
|
|
}
|
|
|
|
dateTimeParser := context.im.dateTimeParserNamed(dateTimeFormat)
|
|
|
|
if dateTimeParser != nil {
|
|
|
|
parsedDateTime, err := dateTimeParser.ParseDateTime(propertyValueString)
|
|
|
|
if err != nil {
|
|
|
|
field, err := document.NewDateTimeFieldWithIndexingOptions(fieldName, indexes, parsedDateTime, options)
|
|
|
|
if err == nil {
|
|
|
|
context.doc.AddField(field)
|
|
|
|
} else {
|
|
|
|
log.Printf("could not build date %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fm *FieldMapping) processFloat64(propertyValFloat float64, pathString string, path []string, indexes []uint64, context *walkContext) {
|
|
|
|
fieldName := getFieldName(pathString, path, fm)
|
|
|
|
if *fm.Type == "number" {
|
|
|
|
options := fm.Options()
|
|
|
|
field := document.NewNumericFieldWithIndexingOptions(fieldName, indexes, propertyValFloat, options)
|
|
|
|
context.doc.AddField(field)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fm *FieldMapping) processTime(propertyValueTime time.Time, pathString string, path []string, indexes []uint64, context *walkContext) {
|
|
|
|
fieldName := getFieldName(pathString, path, fm)
|
|
|
|
if *fm.Type == "datetime" {
|
|
|
|
options := fm.Options()
|
|
|
|
field, err := document.NewDateTimeFieldWithIndexingOptions(fieldName, indexes, propertyValueTime, options)
|
|
|
|
if err == nil {
|
|
|
|
context.doc.AddField(field)
|
|
|
|
} else {
|
|
|
|
log.Printf("could not build date %v", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (fm *FieldMapping) analyzerForField(path []string, context *walkContext) *analysis.Analyzer {
|
|
|
|
analyzerName := context.dm.defaultAnalyzerName(path)
|
|
|
|
if analyzerName == "" {
|
|
|
|
analyzerName = context.im.DefaultAnalyzer
|
|
|
|
}
|
|
|
|
if fm.Analyzer != nil && *fm.Analyzer != "" {
|
|
|
|
analyzerName = *fm.Analyzer
|
|
|
|
}
|
|
|
|
return context.im.analyzerNamed(analyzerName)
|
|
|
|
}
|
|
|
|
|
|
|
|
func getFieldName(pathString string, path []string, fieldMapping *FieldMapping) string {
|
|
|
|
fieldName := pathString
|
|
|
|
if fieldMapping.Name != nil && *fieldMapping.Name != "" {
|
|
|
|
parentName := ""
|
|
|
|
if len(path) > 1 {
|
|
|
|
parentName = encodePath(path[:len(path)-1]) + pathSeparator
|
|
|
|
}
|
|
|
|
fieldName = parentName + *fieldMapping.Name
|
|
|
|
}
|
|
|
|
return fieldName
|
|
|
|
}
|