Debian Codegraph @

suggester_phrase.go

raw
1 // Copyright 2012-present Oliver Eilhard. All rights reserved.
2 // Use of this source code is governed by a MIT-license.
3 // See http://olivere.mit-license.org/license.txt for details.
4
5 package elastic
6
7 // PhraseSuggester provides an API to access word alternatives
8 // on a per token basis within a certain string distance.
9 // For more details, see
10 // https://www.elastic.co/guide/en/elasticsearch/reference/5.2/search-suggesters-phrase.html.
11 type PhraseSuggester struct {
12 Suggester
13 name string
14 text string
15 field string
16 analyzer string
17 size *int
18 shardSize *int
19 contextQueries []SuggesterContextQuery
20
21 // fields specific to a phrase suggester
22 maxErrors *float64
23 separator *string
24 realWordErrorLikelihood *float64
25 confidence *float64
26 generators map[string][]CandidateGenerator
27 gramSize *int
28 smoothingModel SmoothingModel
29 forceUnigrams *bool
30 tokenLimit *int
31 preTag, postTag *string
32 collateQuery *string
33 collatePreference *string
34 collateParams map[string]interface{}
35 collatePrune *bool
36 }
37
38 // NewPhraseSuggester creates a new PhraseSuggester.
39 func NewPhraseSuggester(name string) *PhraseSuggester {
40 return &PhraseSuggester{
41 name: name,
42 collateParams: make(map[string]interface{}),
43 }
44 }
45
46 func (q *PhraseSuggester) Name() string {
47 return q.name
48 }
49
50 func (q *PhraseSuggester) Text(text string) *PhraseSuggester {
51 q.text = text
52 return q
53 }
54
55 func (q *PhraseSuggester) Field(field string) *PhraseSuggester {
56 q.field = field
57 return q
58 }
59
60 func (q *PhraseSuggester) Analyzer(analyzer string) *PhraseSuggester {
61 q.analyzer = analyzer
62 return q
63 }
64
65 func (q *PhraseSuggester) Size(size int) *PhraseSuggester {
66 q.size = &size
67 return q
68 }
69
70 func (q *PhraseSuggester) ShardSize(shardSize int) *PhraseSuggester {
71 q.shardSize = &shardSize
72 return q
73 }
74
75 func (q *PhraseSuggester) ContextQuery(query SuggesterContextQuery) *PhraseSuggester {
76 q.contextQueries = append(q.contextQueries, query)
77 return q
78 }
79
80 func (q *PhraseSuggester) ContextQueries(queries ...SuggesterContextQuery) *PhraseSuggester {
81 q.contextQueries = append(q.contextQueries, queries...)
82 return q
83 }
84
85 func (q *PhraseSuggester) GramSize(gramSize int) *PhraseSuggester {
86 if gramSize >= 1 {
87 q.gramSize = &gramSize
88 }
89 return q
90 }
91
92 func (q *PhraseSuggester) MaxErrors(maxErrors float64) *PhraseSuggester {
93 q.maxErrors = &maxErrors
94 return q
95 }
96
97 func (q *PhraseSuggester) Separator(separator string) *PhraseSuggester {
98 q.separator = &separator
99 return q
100 }
101
102 func (q *PhraseSuggester) RealWordErrorLikelihood(realWordErrorLikelihood float64) *PhraseSuggester {
103 q.realWordErrorLikelihood = &realWordErrorLikelihood
104 return q
105 }
106
107 func (q *PhraseSuggester) Confidence(confidence float64) *PhraseSuggester {
108 q.confidence = &confidence
109 return q
110 }
111
112 func (q *PhraseSuggester) CandidateGenerator(generator CandidateGenerator) *PhraseSuggester {
113 if q.generators == nil {
114 q.generators = make(map[string][]CandidateGenerator)
115 }
116 typ := generator.Type()
117 if _, found := q.generators[typ]; !found {
118 q.generators[typ] = make([]CandidateGenerator, 0)
119 }
120 q.generators[typ] = append(q.generators[typ], generator)
121 return q
122 }
123
124 func (q *PhraseSuggester) CandidateGenerators(generators ...CandidateGenerator) *PhraseSuggester {
125 for _, g := range generators {
126 q = q.CandidateGenerator(g)
127 }
128 return q
129 }
130
131 func (q *PhraseSuggester) ClearCandidateGenerator() *PhraseSuggester {
132 q.generators = nil
133 return q
134 }
135
136 func (q *PhraseSuggester) ForceUnigrams(forceUnigrams bool) *PhraseSuggester {
137 q.forceUnigrams = &forceUnigrams
138 return q
139 }
140
141 func (q *PhraseSuggester) SmoothingModel(smoothingModel SmoothingModel) *PhraseSuggester {
142 q.smoothingModel = smoothingModel
143 return q
144 }
145
146 func (q *PhraseSuggester) TokenLimit(tokenLimit int) *PhraseSuggester {
147 q.tokenLimit = &tokenLimit
148 return q
149 }
150
151 func (q *PhraseSuggester) Highlight(preTag, postTag string) *PhraseSuggester {
152 q.preTag = &preTag
153 q.postTag = &postTag
154 return q
155 }
156
157 func (q *PhraseSuggester) CollateQuery(collateQuery string) *PhraseSuggester {
158 q.collateQuery = &collateQuery
159 return q
160 }
161
162 func (q *PhraseSuggester) CollatePreference(collatePreference string) *PhraseSuggester {
163 q.collatePreference = &collatePreference
164 return q
165 }
166
167 func (q *PhraseSuggester) CollateParams(collateParams map[string]interface{}) *PhraseSuggester {
168 q.collateParams = collateParams
169 return q
170 }
171
172 func (q *PhraseSuggester) CollatePrune(collatePrune bool) *PhraseSuggester {
173 q.collatePrune = &collatePrune
174 return q
175 }
176
177 // phraseSuggesterRequest is necessary because the order in which
178 // the JSON elements are routed to Elasticsearch is relevant.
179 // We got into trouble when using plain maps because the text element
180 // needs to go before the simple_phrase element.
181 type phraseSuggesterRequest struct {
182 Text string `json:"text"`
183 Phrase interface{} `json:"phrase"`
184 }
185
186 // Source generates the source for the phrase suggester.
187 func (q *PhraseSuggester) Source(includeName bool) (interface{}, error) {
188 ps := &phraseSuggesterRequest{}
189
190 if q.text != "" {
191 ps.Text = q.text
192 }
193
194 suggester := make(map[string]interface{})
195 ps.Phrase = suggester
196
197 if q.analyzer != "" {
198 suggester["analyzer"] = q.analyzer
199 }
200 if q.field != "" {
201 suggester["field"] = q.field
202 }
203 if q.size != nil {
204 suggester["size"] = *q.size
205 }
206 if q.shardSize != nil {
207 suggester["shard_size"] = *q.shardSize
208 }
209 switch len(q.contextQueries) {
210 case 0:
211 case 1:
212 src, err := q.contextQueries[0].Source()
213 if err != nil {
214 return nil, err
215 }
216 suggester["context"] = src
217 default:
218 var ctxq []interface{}
219 for _, query := range q.contextQueries {
220 src, err := query.Source()
221 if err != nil {
222 return nil, err
223 }
224 ctxq = append(ctxq, src)
225 }
226 suggester["context"] = ctxq
227 }
228
229 // Phase-specified parameters
230 if q.realWordErrorLikelihood != nil {
231 suggester["real_word_error_likelihood"] = *q.realWordErrorLikelihood
232 }
233 if q.confidence != nil {
234 suggester["confidence"] = *q.confidence
235 }
236 if q.separator != nil {
237 suggester["separator"] = *q.separator
238 }
239 if q.maxErrors != nil {
240 suggester["max_errors"] = *q.maxErrors
241 }
242 if q.gramSize != nil {
243 suggester["gram_size"] = *q.gramSize
244 }
245 if q.forceUnigrams != nil {
246 suggester["force_unigrams"] = *q.forceUnigrams
247 }
248 if q.tokenLimit != nil {
249 suggester["token_limit"] = *q.tokenLimit
250 }
251 if q.generators != nil && len(q.generators) > 0 {
252 for typ, generators := range q.generators {
253 var arr []interface{}
254 for _, g := range generators {
255 src, err := g.Source()
256 if err != nil {
257 return nil, err
258 }
259 arr = append(arr, src)
260 }
261 suggester[typ] = arr
262 }
263 }
264 if q.smoothingModel != nil {
265 src, err := q.smoothingModel.Source()
266 if err != nil {
267 return nil, err
268 }
269 x := make(map[string]interface{})
270 x[q.smoothingModel.Type()] = src
271 suggester["smoothing"] = x
272 }
273 if q.preTag != nil {
274 hl := make(map[string]string)
275 hl["pre_tag"] = *q.preTag
276 if q.postTag != nil {
277 hl["post_tag"] = *q.postTag
278 }
279 suggester["highlight"] = hl
280 }
281 if q.collateQuery != nil {
282 collate := make(map[string]interface{})
283 suggester["collate"] = collate
284 if q.collateQuery != nil {
285 collate["query"] = *q.collateQuery
286 }
287 if q.collatePreference != nil {
288 collate["preference"] = *q.collatePreference
289 }
290 if len(q.collateParams) > 0 {
291 collate["params"] = q.collateParams
292 }
293 if q.collatePrune != nil {
294 collate["prune"] = *q.collatePrune
295 }
296 }
297
298 if !includeName {
299 return ps, nil
300 }
301
302 source := make(map[string]interface{})
303 source[q.name] = ps
304 return source, nil
305 }
306
307 // -- Smoothing models --
308
309 type SmoothingModel interface {
310 Type() string
311 Source() (interface{}, error)
312 }
313
314 // StupidBackoffSmoothingModel implements a stupid backoff smoothing model.
315 // See https://www.elastic.co/guide/en/elasticsearch/reference/5.2/search-suggesters-phrase.html#_smoothing_models
316 // for details about smoothing models.
317 type StupidBackoffSmoothingModel struct {
318 discount float64
319 }
320
321 func NewStupidBackoffSmoothingModel(discount float64) *StupidBackoffSmoothingModel {
322 return &StupidBackoffSmoothingModel{
323 discount: discount,
324 }
325 }
326
327 func (sm *StupidBackoffSmoothingModel) Type() string {
328 return "stupid_backoff"
329 }
330
331 func (sm *StupidBackoffSmoothingModel) Source() (interface{}, error) {
332 source := make(map[string]interface{})
333 source["discount"] = sm.discount
334 return source, nil
335 }
336
337 // --
338
339 // LaplaceSmoothingModel implements a laplace smoothing model.
340 // See https://www.elastic.co/guide/en/elasticsearch/reference/5.2/search-suggesters-phrase.html#_smoothing_models
341 // for details about smoothing models.
342 type LaplaceSmoothingModel struct {
343 alpha float64
344 }
345
346 func NewLaplaceSmoothingModel(alpha float64) *LaplaceSmoothingModel {
347 return &LaplaceSmoothingModel{
348 alpha: alpha,
349 }
350 }
351
352 func (sm *LaplaceSmoothingModel) Type() string {
353 return "laplace"
354 }
355
356 func (sm *LaplaceSmoothingModel) Source() (interface{}, error) {
357 source := make(map[string]interface{})
358 source["alpha"] = sm.alpha
359 return source, nil
360 }
361
362 // --
363
364 // LinearInterpolationSmoothingModel implements a linear interpolation
365 // smoothing model.
366 // See https://www.elastic.co/guide/en/elasticsearch/reference/5.2/search-suggesters-phrase.html#_smoothing_models
367 // for details about smoothing models.
368 type LinearInterpolationSmoothingModel struct {
369 trigramLamda float64
370 bigramLambda float64
371 unigramLambda float64
372 }
373
374 func NewLinearInterpolationSmoothingModel(trigramLamda, bigramLambda, unigramLambda float64) *LinearInterpolationSmoothingModel {
375 return &LinearInterpolationSmoothingModel{
376 trigramLamda: trigramLamda,
377 bigramLambda: bigramLambda,
378 unigramLambda: unigramLambda,
379 }
380 }
381
382 func (sm *LinearInterpolationSmoothingModel) Type() string {
383 return "linear_interpolation"
384 }
385
386 func (sm *LinearInterpolationSmoothingModel) Source() (interface{}, error) {
387 source := make(map[string]interface{})
388 source["trigram_lambda"] = sm.trigramLamda
389 source["bigram_lambda"] = sm.bigramLambda
390 source["unigram_lambda"] = sm.unigramLambda
391 return source, nil
392 }
393
394 // -- CandidateGenerator --
395
396 type CandidateGenerator interface {
397 Type() string
398 Source() (interface{}, error)
399 }
400
401 // DirectCandidateGenerator implements a direct candidate generator.
402 // See https://www.elastic.co/guide/en/elasticsearch/reference/5.2/search-suggesters-phrase.html#_smoothing_models
403 // for details about smoothing models.
404 type DirectCandidateGenerator struct {
405 field string
406 preFilter *string
407 postFilter *string
408 suggestMode *string
409 accuracy *float64
410 size *int
411 sort *string
412 stringDistance *string
413 maxEdits *int
414 maxInspections *int
415 maxTermFreq *float64
416 prefixLength *int
417 minWordLength *int
418 minDocFreq *float64
419 }
420
421 func NewDirectCandidateGenerator(field string) *DirectCandidateGenerator {
422 return &DirectCandidateGenerator{
423 field: field,
424 }
425 }
426
427 func (g *DirectCandidateGenerator) Type() string {
428 return "direct_generator"
429 }
430
431 func (g *DirectCandidateGenerator) Field(field string) *DirectCandidateGenerator {
432 g.field = field
433 return g
434 }
435
436 func (g *DirectCandidateGenerator) PreFilter(preFilter string) *DirectCandidateGenerator {
437 g.preFilter = &preFilter
438 return g
439 }
440
441 func (g *DirectCandidateGenerator) PostFilter(postFilter string) *DirectCandidateGenerator {
442 g.postFilter = &postFilter
443 return g
444 }
445
446 func (g *DirectCandidateGenerator) SuggestMode(suggestMode string) *DirectCandidateGenerator {
447 g.suggestMode = &suggestMode
448 return g
449 }
450
451 func (g *DirectCandidateGenerator) Accuracy(accuracy float64) *DirectCandidateGenerator {
452 g.accuracy = &accuracy
453 return g
454 }
455
456 func (g *DirectCandidateGenerator) Size(size int) *DirectCandidateGenerator {
457 g.size = &size
458 return g
459 }
460
461 func (g *DirectCandidateGenerator) Sort(sort string) *DirectCandidateGenerator {
462 g.sort = &sort
463 return g
464 }
465
466 func (g *DirectCandidateGenerator) StringDistance(stringDistance string) *DirectCandidateGenerator {
467 g.stringDistance = &stringDistance
468 return g
469 }
470
471 func (g *DirectCandidateGenerator) MaxEdits(maxEdits int) *DirectCandidateGenerator {
472 g.maxEdits = &maxEdits
473 return g
474 }
475
476 func (g *DirectCandidateGenerator) MaxInspections(maxInspections int) *DirectCandidateGenerator {
477 g.maxInspections = &maxInspections
478 return g
479 }
480
481 func (g *DirectCandidateGenerator) MaxTermFreq(maxTermFreq float64) *DirectCandidateGenerator {
482 g.maxTermFreq = &maxTermFreq
483 return g
484 }
485
486 func (g *DirectCandidateGenerator) PrefixLength(prefixLength int) *DirectCandidateGenerator {
487 g.prefixLength = &prefixLength
488 return g
489 }
490
491 func (g *DirectCandidateGenerator) MinWordLength(minWordLength int) *DirectCandidateGenerator {
492 g.minWordLength = &minWordLength
493 return g
494 }
495
496 func (g *DirectCandidateGenerator) MinDocFreq(minDocFreq float64) *DirectCandidateGenerator {
497 g.minDocFreq = &minDocFreq
498 return g
499 }
500
501 func (g *DirectCandidateGenerator) Source() (interface{}, error) {
502 source := make(map[string]interface{})
503 if g.field != "" {
504 source["field"] = g.field
505 }
506 if g.suggestMode != nil {
507 source["suggest_mode"] = *g.suggestMode
508 }
509 if g.accuracy != nil {
510 source["accuracy"] = *g.accuracy
511 }
512 if g.size != nil {
513 source["size"] = *g.size
514 }
515 if g.sort != nil {
516 source["sort"] = *g.sort
517 }
518 if g.stringDistance != nil {
519 source["string_distance"] = *g.stringDistance
520 }
521 if g.maxEdits != nil {
522 source["max_edits"] = *g.maxEdits
523 }
524 if g.maxInspections != nil {
525 source["max_inspections"] = *g.maxInspections
526 }
527 if g.maxTermFreq != nil {
528 source["max_term_freq"] = *g.maxTermFreq
529 }
530 if g.prefixLength != nil {
531 source["prefix_length"] = *g.prefixLength
532 }
533 if g.minWordLength != nil {
534 source["min_word_length"] = *g.minWordLength
535 }
536 if g.minDocFreq != nil {
537 source["min_doc_freq"] = *g.minDocFreq
538 }
539 if g.preFilter != nil {
540 source["pre_filter"] = *g.preFilter
541 }
542 if g.postFilter != nil {
543 source["post_filter"] = *g.postFilter
544 }
545 return source, nil
546 }