package esquery import ( "github.com/fatih/structs" ) // Map returns a map representation of the highlight; implementing the // Mappable interface. func (q *QueryHighlight) Map() map[string]interface{} { results := structs.Map(q.params) if q.highlightQuery != nil { results["highlight_query"] = q.highlightQuery.Map() } if q.fields != nil && len(q.fields) > 0 { fields := make(map[string]interface{}) for k, v := range q.fields { fields[k] = v.Map() } results["fields"] = fields } return results } type QueryHighlight struct { highlightQuery Mappable `structs:"highlight_query,omitempty"` fields map[string]*QueryHighlight `structs:"fields"` params highlighParams } type highlighParams struct { PreTags []string `structs:"pre_tags,omitempty"` PostTags []string `structs:"post_tags,omitempty"` FragmentSize uint16 `structs:"fragment_size,omitempty"` NumberOfFragments uint16 `structs:"number_of_fragments,omitempty"` Type HighlightType `structs:"type,string,omitempty"` BoundaryChars string `structs:"boundary_chars,omitempty"` BoundaryMaxScan uint16 `structs:"boundary_max_scan,omitempty"` BoundaryScanner HighlightBoundaryScanner `structs:"boundary_scanner,string,omitempty"` BoundaryScannerLocale string `structs:"boundary_scanner_locale,omitempty"` Encoder HighlightEncoder `structs:"encoder,string,omitempty"` ForceSource *bool `structs:"force_source,omitempty"` Fragmenter HighlightFragmenter `structs:"fragmenter,string,omitempty"` FragmentOffset uint16 `structs:"fragment_offset,omitempty"` MatchedFields []string `structs:"matched_fields,omitempty"` NoMatchSize uint16 `structs:"no_match_size,omitempty"` Order HighlightOrder `structs:"order,string,omitempty"` PhraseLimit uint16 `structs:"phrase_limit,omitempty"` RequireFieldMatch *bool `structs:"require_field_match,omitempty"` TagsSchema HighlightTagsSchema `structs:"tags_schema,string,omitempty"` } // Highlight creates a new "query" of type "highlight" func Highlight() *QueryHighlight { return newHighlight() } func newHighlight() *QueryHighlight { return &QueryHighlight{ fields: make(map[string]*QueryHighlight), params: highlighParams{}, } } // PreTags sets the highlight query's pre_tags ignore unmapped field func (q *QueryHighlight) PreTags(s ...string) *QueryHighlight { q.params.PreTags = append(q.params.PreTags, s...) return q } // PostTags sets the highlight query's post_tags ignore unmapped field func (q *QueryHighlight) PostTags(s ...string) *QueryHighlight { q.params.PostTags = append(q.params.PostTags, s...) return q } // Field sets an entry the highlight query's fields func (q *QueryHighlight) Field(name string, h ...*QueryHighlight) *QueryHighlight { var fld *QueryHighlight if len(h) > 0 { fld = h[len(h)-1] } else { fld = &QueryHighlight{} } q.fields[name] = fld return q } // Fields sets all entries for the highlight query's fields func (q *QueryHighlight) Fields(h map[string]*QueryHighlight) *QueryHighlight { q.fields = h return q } // FragmentSize sets the highlight query's fragment_size ignore unmapped field func (q *QueryHighlight) FragmentSize(i uint16) *QueryHighlight { q.params.FragmentSize = i return q } // NumberOfFragments sets the highlight query's number_of_fragments ignore unmapped field func (q *QueryHighlight) NumberOfFragments(i uint16) *QueryHighlight { q.params.NumberOfFragments = i return q } // Type sets the highlight query's type ignore unmapped field func (q *QueryHighlight) Type(t HighlightType) *QueryHighlight { q.params.Type = t return q } // BoundaryChars sets the highlight query's boundary_chars ignore unmapped field func (q *QueryHighlight) BoundaryChars(s string) *QueryHighlight { q.params.BoundaryChars = s return q } // BoundaryMaxScan sets the highlight query's boundary_max_scan ignore unmapped field func (q *QueryHighlight) BoundaryMaxScan(i uint16) *QueryHighlight { q.params.BoundaryMaxScan = i return q } // BoundaryScanner sets the highlight query's boundary_scanner ignore unmapped field func (q *QueryHighlight) BoundaryScanner(t HighlightBoundaryScanner) *QueryHighlight { q.params.BoundaryScanner = t return q } // BoundaryScannerLocale sets the highlight query's boundary_scanner_locale ignore unmapped field func (q *QueryHighlight) BoundaryScannerLocale(l string) *QueryHighlight { q.params.BoundaryScannerLocale = l return q } // Encoder sets the highlight query's encoder ignore unmapped field func (q *QueryHighlight) Encoder(e HighlightEncoder) *QueryHighlight { q.params.Encoder = e return q } // ForceSource sets the highlight query's force_source ignore unmapped field func (q *QueryHighlight) ForceSource(b bool) *QueryHighlight { q.params.ForceSource = &b return q } // Fragmenter sets the highlight query's fragmenter ignore unmapped field func (q *QueryHighlight) Fragmenter(f HighlightFragmenter) *QueryHighlight { q.params.Fragmenter = f return q } // FragmentOffset sets the highlight query's fragment_offset ignore unmapped field func (q *QueryHighlight) FragmentOffset(i uint16) *QueryHighlight { q.params.FragmentOffset = i return q } // HighlightQuery sets the highlight query's highlight_query ignore unmapped field func (q *QueryHighlight) HighlightQuery(b Mappable) *QueryHighlight { q.highlightQuery = b return q } // MatchedFields sets the highlight query's matched_fields ignore unmapped field func (q *QueryHighlight) MatchedFields(s ...string) *QueryHighlight { q.params.MatchedFields = append(q.params.MatchedFields, s...) return q } // NoMatchSize sets the highlight query's no_match_size ignore unmapped field func (q *QueryHighlight) NoMatchSize(i uint16) *QueryHighlight { q.params.NoMatchSize = i return q } // Order sets the nested highlight's score order unmapped field func (q *QueryHighlight) Order(o HighlightOrder) *QueryHighlight { q.params.Order = o return q } // PhraseLimit sets the highlight query's phrase_limit ignore unmapped field func (q *QueryHighlight) PhraseLimit(i uint16) *QueryHighlight { q.params.PhraseLimit = i return q } // RequireFieldMatch sets the highlight query's require_field_match ignore unmapped field func (q *QueryHighlight) RequireFieldMatch(b bool) *QueryHighlight { q.params.RequireFieldMatch = &b return q } // TagsSchema sets the highlight query's tags_schema ignore unmapped field func (q *QueryHighlight) TagsSchema(s HighlightTagsSchema) *QueryHighlight { q.params.TagsSchema = s return q } type HighlightType uint8 const ( // HighlighterUnified is the "unified" value HighlighterUnified HighlightType = iota // HighlighterPlain is the "plain" value HighlighterPlain // HighlighterFvh is the "fvh" value HighlighterFvh ) // String returns a string representation of the type parameter, as // known to ElasticSearch. func (a HighlightType) String() string { switch a { case HighlighterUnified: return "unified" case HighlighterPlain: return "plain" case HighlighterFvh: return "fvh" } return "" } type HighlightBoundaryScanner uint8 const ( BoundaryScannerDefault HighlightBoundaryScanner = iota // BoundaryScannerChars is the "chars" value BoundaryScannerChars // BoundaryScannerSentence is the "sentence" value BoundaryScannerSentence // BoundaryScannerWord is the "word" value BoundaryScannerWord ) // String returns a string representation of the boundary_scanner parameter, as // known to ElasticSearch. func (a HighlightBoundaryScanner) String() string { switch a { case BoundaryScannerChars: return "chars" case BoundaryScannerSentence: return "sentence" case BoundaryScannerWord: return "word" default: return "" } } type HighlightEncoder uint8 const ( // EncoderDefault is the "default" value EncoderDefault HighlightEncoder = iota // EncoderHtml is the "html" value EncoderHtml ) // String returns a string representation of the encoder parameter, as // known to ElasticSearch. func (a HighlightEncoder) String() string { switch a { case EncoderDefault: return "default" case EncoderHtml: return "html" } return "" } type HighlightFragmenter uint8 const ( // FragmenterSpan is the "span" value FragmenterSpan HighlightFragmenter = iota // FragmenterSimple is the "simple" value FragmenterSimple ) // String returns a string representation of the fragmenter parameter, as // known to ElasticSearch. func (a HighlightFragmenter) String() string { switch a { case FragmenterSpan: return "span" case FragmenterSimple: return "simple" } return "" } type HighlightOrder uint8 const ( // OrderNone is the "none" value OrderNone HighlightOrder = iota // OrderScore is the "score" value OrderScore ) // String returns a string representation of the order parameter, as // known to ElasticSearch. func (a HighlightOrder) String() string { switch a { case OrderNone: return "none" case OrderScore: return "score" } return "" } type HighlightTagsSchema uint8 const ( TagsSchemaDefault HighlightTagsSchema = iota // TagsSchemaStyled is the "styled" value TagsSchemaStyled ) // String returns a string representation of the tags_schema parameter, as // known to ElasticSearch. func (a HighlightTagsSchema) String() string { switch a { case TagsSchemaStyled: return "styled" default: return "" } }