query

package
v2.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 16, 2021 License: Apache-2.0 Imports: 21 Imported by: 79

Documentation

Index

Constants

View Source 
const (
	// Document must satisfy AT LEAST ONE of term searches.
	MatchQueryOperatorOr = MatchQueryOperator(0)
	// Document must satisfy ALL of term searches.
	MatchQueryOperatorAnd = MatchQueryOperator(1)
)

Variables

View Source 
var MaxRFC3339CompatibleTime time.Time
View Source 
var MinRFC3339CompatibleTime time.Time
View Source 
var QueryDateTimeFormat = time.RFC3339

QueryDateTimeFormat controls the format when Marshaling to JSON

View Source 
var QueryDateTimeParser = optional.Name

QueryDateTimeParser controls the default query date time parser

Functions

func DumpQuery 

func DumpQuery(m mapping.IndexMapping, query Query) (string, error)

DumpQuery returns a string representation of the query tree, where query string queries have been expanded into base queries. The output format is meant for debugging purpose and may change in the future.

func SetLog 

func SetLog(l *log.Logger)

SetLog sets the logger used for logging by default log messages are sent to ioutil.Discard

Types

type BleveQueryTime 

type BleveQueryTime struct {
	time.Time
}

func (*BleveQueryTime) MarshalJSON 

func (t *BleveQueryTime) MarshalJSON() ([]byte, error)

func (*BleveQueryTime) UnmarshalJSON 

func (t *BleveQueryTime) UnmarshalJSON(data []byte) error

type BoolFieldQuery 

type BoolFieldQuery struct {
	Bool     bool   `json:"bool"`
	FieldVal string `json:"field,omitempty"`
	BoostVal *Boost `json:"boost,omitempty"`
}

func NewBoolFieldQuery 

func NewBoolFieldQuery(val bool) *BoolFieldQuery

NewBoolFieldQuery creates a new Query for boolean fields

func (*BoolFieldQuery) Boost 

func (q *BoolFieldQuery) Boost() float64

func (*BoolFieldQuery) Field 

func (q *BoolFieldQuery) Field() string

func (*BoolFieldQuery) Searcher 

func (q *BoolFieldQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*BoolFieldQuery) SetBoost 

func (q *BoolFieldQuery) SetBoost(b float64)

func (*BoolFieldQuery) SetField 

func (q *BoolFieldQuery) SetField(f string)

type BooleanQuery 

type BooleanQuery struct {
	Must     Query  `json:"must,omitempty"`
	Should   Query  `json:"should,omitempty"`
	MustNot  Query  `json:"must_not,omitempty"`
	BoostVal *Boost `json:"boost,omitempty"`
	// contains filtered or unexported fields
}

func NewBooleanQuery 

func NewBooleanQuery(must []Query, should []Query, mustNot []Query) *BooleanQuery

NewBooleanQuery creates a compound Query composed of several other Query objects. Result documents must satisfy ALL of the must Queries. Result documents must satisfy NONE of the must not Queries. Result documents that ALSO satisfy any of the should Queries will score higher.

func NewBooleanQueryForQueryString 

func NewBooleanQueryForQueryString(must []Query, should []Query, mustNot []Query) *BooleanQuery

func (*BooleanQuery) AddMust 

func (q *BooleanQuery) AddMust(m ...Query)

func (*BooleanQuery) AddMustNot 

func (q *BooleanQuery) AddMustNot(m ...Query)

func (*BooleanQuery) AddShould 

func (q *BooleanQuery) AddShould(m ...Query)

func (*BooleanQuery) Boost 

func (q *BooleanQuery) Boost() float64

func (*BooleanQuery) Searcher 

func (q *BooleanQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*BooleanQuery) SetBoost 

func (q *BooleanQuery) SetBoost(b float64)

func (*BooleanQuery) SetMinShould 

func (q *BooleanQuery) SetMinShould(minShould float64)

SetMinShould requires that at least minShould of the should Queries must be satisfied.

func (*BooleanQuery) UnmarshalJSON 

func (q *BooleanQuery) UnmarshalJSON(data []byte) error

func (*BooleanQuery) Validate 

func (q *BooleanQuery) Validate() error

type Boost 

type Boost float64

func (*Boost) GoString 

func (b *Boost) GoString() string

func (*Boost) Value 

func (b *Boost) Value() float64

type BoostableQuery 

type BoostableQuery interface {
	Query
	SetBoost(b float64)
	Boost() float64
}

A BoostableQuery represents a Query which can be boosted relative to other queries.

type ConjunctionQuery 

type ConjunctionQuery struct {
	Conjuncts []Query `json:"conjuncts"`
	BoostVal  *Boost  `json:"boost,omitempty"`
	// contains filtered or unexported fields
}

func NewConjunctionQuery 

func NewConjunctionQuery(conjuncts []Query) *ConjunctionQuery

NewConjunctionQuery creates a new compound Query. Result documents must satisfy all of the queries.

func (*ConjunctionQuery) AddQuery 

func (q *ConjunctionQuery) AddQuery(aq ...Query)

func (*ConjunctionQuery) Boost 

func (q *ConjunctionQuery) Boost() float64

func (*ConjunctionQuery) Searcher 

func (q *ConjunctionQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*ConjunctionQuery) SetBoost 

func (q *ConjunctionQuery) SetBoost(b float64)

func (*ConjunctionQuery) UnmarshalJSON 

func (q *ConjunctionQuery) UnmarshalJSON(data []byte) error

func (*ConjunctionQuery) Validate 

func (q *ConjunctionQuery) Validate() error

type DateRangeQuery 

type DateRangeQuery struct {
	Start          BleveQueryTime `json:"start,omitempty"`
	End            BleveQueryTime `json:"end,omitempty"`
	InclusiveStart *bool          `json:"inclusive_start,omitempty"`
	InclusiveEnd   *bool          `json:"inclusive_end,omitempty"`
	FieldVal       string         `json:"field,omitempty"`
	BoostVal       *Boost         `json:"boost,omitempty"`
}

func NewDateRangeInclusiveQuery 

func NewDateRangeInclusiveQuery(start, end time.Time, startInclusive, endInclusive *bool) *DateRangeQuery

NewDateRangeInclusiveQuery creates a new Query for ranges of date values. Date strings are parsed using the DateTimeParser configured in the 

top-level config.QueryDateTimeParser

Either, but not both endpoints can be nil. startInclusive and endInclusive control inclusion of the endpoints.

func NewDateRangeQuery 

func NewDateRangeQuery(start, end time.Time) *DateRangeQuery

NewDateRangeQuery creates a new Query for ranges of date values. Date strings are parsed using the DateTimeParser configured in the 

top-level config.QueryDateTimeParser

Either, but not both endpoints can be nil.

func (*DateRangeQuery) Boost 

func (q *DateRangeQuery) Boost() float64

func (*DateRangeQuery) Field 

func (q *DateRangeQuery) Field() string

func (*DateRangeQuery) Searcher 

func (q *DateRangeQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*DateRangeQuery) SetBoost 

func (q *DateRangeQuery) SetBoost(b float64)

func (*DateRangeQuery) SetField 

func (q *DateRangeQuery) SetField(f string)

func (*DateRangeQuery) Validate 

func (q *DateRangeQuery) Validate() error

type DisjunctionQuery 

type DisjunctionQuery struct {
	Disjuncts []Query `json:"disjuncts"`
	BoostVal  *Boost  `json:"boost,omitempty"`
	Min       float64 `json:"min"`
	// contains filtered or unexported fields
}

func NewDisjunctionQuery 

func NewDisjunctionQuery(disjuncts []Query) *DisjunctionQuery

NewDisjunctionQuery creates a new compound Query. Result documents satisfy at least one Query.

func (*DisjunctionQuery) AddQuery 

func (q *DisjunctionQuery) AddQuery(aq ...Query)

func (*DisjunctionQuery) Boost 

func (q *DisjunctionQuery) Boost() float64

func (*DisjunctionQuery) Searcher 

func (q *DisjunctionQuery) Searcher(i index.IndexReader, m mapping.IndexMapping,
	options search.SearcherOptions) (search.Searcher, error)

func (*DisjunctionQuery) SetBoost 

func (q *DisjunctionQuery) SetBoost(b float64)

func (*DisjunctionQuery) SetMin 

func (q *DisjunctionQuery) SetMin(m float64)

func (*DisjunctionQuery) UnmarshalJSON 

func (q *DisjunctionQuery) UnmarshalJSON(data []byte) error

func (*DisjunctionQuery) Validate 

func (q *DisjunctionQuery) Validate() error

type DocIDQuery 

type DocIDQuery struct {
	IDs      []string `json:"ids"`
	BoostVal *Boost   `json:"boost,omitempty"`
}

func NewDocIDQuery 

func NewDocIDQuery(ids []string) *DocIDQuery

NewDocIDQuery creates a new Query object returning indexed documents among the specified set. Combine it with ConjunctionQuery to restrict the scope of other queries output.

func (*DocIDQuery) Boost 

func (q *DocIDQuery) Boost() float64

func (*DocIDQuery) Searcher 

func (q *DocIDQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*DocIDQuery) SetBoost 

func (q *DocIDQuery) SetBoost(b float64)

type FieldableQuery 

type FieldableQuery interface {
	Query
	SetField(f string)
	Field() string
}

A FieldableQuery represents a Query which can be restricted to a single field.

type FuzzyQuery 

type FuzzyQuery struct {
	Term      string `json:"term"`
	Prefix    int    `json:"prefix_length"`
	Fuzziness int    `json:"fuzziness"`
	FieldVal  string `json:"field,omitempty"`
	BoostVal  *Boost `json:"boost,omitempty"`
}

func NewFuzzyQuery 

func NewFuzzyQuery(term string) *FuzzyQuery

NewFuzzyQuery creates a new Query which finds documents containing terms within a specific fuzziness of the specified term. The default fuzziness is 1.

The current implementation uses Levenshtein edit distance as the fuzziness metric.

func (*FuzzyQuery) Boost 

func (q *FuzzyQuery) Boost() float64

func (*FuzzyQuery) Field 

func (q *FuzzyQuery) Field() string

func (*FuzzyQuery) Searcher 

func (q *FuzzyQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*FuzzyQuery) SetBoost 

func (q *FuzzyQuery) SetBoost(b float64)

func (*FuzzyQuery) SetField 

func (q *FuzzyQuery) SetField(f string)

func (*FuzzyQuery) SetFuzziness 

func (q *FuzzyQuery) SetFuzziness(f int)

func (*FuzzyQuery) SetPrefix 

func (q *FuzzyQuery) SetPrefix(p int)

type GeoBoundingBoxQuery 

type GeoBoundingBoxQuery struct {
	TopLeft     []float64 `json:"top_left,omitempty"`
	BottomRight []float64 `json:"bottom_right,omitempty"`
	FieldVal    string    `json:"field,omitempty"`
	BoostVal    *Boost    `json:"boost,omitempty"`
}

func NewGeoBoundingBoxQuery 

func NewGeoBoundingBoxQuery(topLeftLon, topLeftLat, bottomRightLon, bottomRightLat float64) *GeoBoundingBoxQuery

func (*GeoBoundingBoxQuery) Boost 

func (q *GeoBoundingBoxQuery) Boost() float64

func (*GeoBoundingBoxQuery) Field 

func (q *GeoBoundingBoxQuery) Field() string

func (*GeoBoundingBoxQuery) Searcher 

func (q *GeoBoundingBoxQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*GeoBoundingBoxQuery) SetBoost 

func (q *GeoBoundingBoxQuery) SetBoost(b float64)

func (*GeoBoundingBoxQuery) SetField 

func (q *GeoBoundingBoxQuery) SetField(f string)

func (*GeoBoundingBoxQuery) UnmarshalJSON 

func (q *GeoBoundingBoxQuery) UnmarshalJSON(data []byte) error

func (*GeoBoundingBoxQuery) Validate 

func (q *GeoBoundingBoxQuery) Validate() error

type GeoBoundingPolygonQuery 

type GeoBoundingPolygonQuery struct {
	Points   []geo.Point `json:"polygon_points"`
	FieldVal string      `json:"field,omitempty"`
	BoostVal *Boost      `json:"boost,omitempty"`
}

func NewGeoBoundingPolygonQuery 

func NewGeoBoundingPolygonQuery(points []geo.Point) *GeoBoundingPolygonQuery

func (*GeoBoundingPolygonQuery) Boost 

func (q *GeoBoundingPolygonQuery) Boost() float64

func (*GeoBoundingPolygonQuery) Field 

func (q *GeoBoundingPolygonQuery) Field() string

func (*GeoBoundingPolygonQuery) Searcher 

func (q *GeoBoundingPolygonQuery) Searcher(i index.IndexReader,
	m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*GeoBoundingPolygonQuery) SetBoost 

func (q *GeoBoundingPolygonQuery) SetBoost(b float64)

func (*GeoBoundingPolygonQuery) SetField 

func (q *GeoBoundingPolygonQuery) SetField(f string)

func (*GeoBoundingPolygonQuery) UnmarshalJSON 

func (q *GeoBoundingPolygonQuery) UnmarshalJSON(data []byte) error

func (*GeoBoundingPolygonQuery) Validate 

func (q *GeoBoundingPolygonQuery) Validate() error

type GeoDistanceQuery 

type GeoDistanceQuery struct {
	Location []float64 `json:"location,omitempty"`
	Distance string    `json:"distance,omitempty"`
	FieldVal string    `json:"field,omitempty"`
	BoostVal *Boost    `json:"boost,omitempty"`
}

func NewGeoDistanceQuery 

func NewGeoDistanceQuery(lon, lat float64, distance string) *GeoDistanceQuery

func (*GeoDistanceQuery) Boost 

func (q *GeoDistanceQuery) Boost() float64

func (*GeoDistanceQuery) Field 

func (q *GeoDistanceQuery) Field() string

func (*GeoDistanceQuery) Searcher 

func (q *GeoDistanceQuery) Searcher(i index.IndexReader, m mapping.IndexMapping,
	options search.SearcherOptions) (search.Searcher, error)

func (*GeoDistanceQuery) SetBoost 

func (q *GeoDistanceQuery) SetBoost(b float64)

func (*GeoDistanceQuery) SetField 

func (q *GeoDistanceQuery) SetField(f string)

func (*GeoDistanceQuery) UnmarshalJSON 

func (q *GeoDistanceQuery) UnmarshalJSON(data []byte) error

func (*GeoDistanceQuery) Validate 

func (q *GeoDistanceQuery) Validate() error

type IPRangeQuery added in v2.3.0 

type IPRangeQuery struct {
	CIDR     string `json:"cidr, omitempty"`
	FieldVal string `json:"field,omitempty"`
	BoostVal *Boost `json:"boost,omitempty"`
}

func NewIPRangeQuery added in v2.3.0 

func NewIPRangeQuery(cidr string) *IPRangeQuery

func (*IPRangeQuery) Boost added in v2.3.0 

func (q *IPRangeQuery) Boost() float64

func (*IPRangeQuery) Field added in v2.3.0 

func (q *IPRangeQuery) Field() string

func (*IPRangeQuery) Searcher added in v2.3.0 

func (q *IPRangeQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*IPRangeQuery) SetBoost added in v2.3.0 

func (q *IPRangeQuery) SetBoost(b float64)

func (*IPRangeQuery) SetField added in v2.3.0 

func (q *IPRangeQuery) SetField(f string)

func (*IPRangeQuery) Validate added in v2.3.0 

func (q *IPRangeQuery) Validate() error

type MatchAllQuery 

type MatchAllQuery struct {
	BoostVal *Boost `json:"boost,omitempty"`
}

func NewMatchAllQuery 

func NewMatchAllQuery() *MatchAllQuery

NewMatchAllQuery creates a Query which will match all documents in the index.

func (*MatchAllQuery) Boost 

func (q *MatchAllQuery) Boost() float64

func (*MatchAllQuery) MarshalJSON 

func (q *MatchAllQuery) MarshalJSON() ([]byte, error)

func (*MatchAllQuery) Searcher 

func (q *MatchAllQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*MatchAllQuery) SetBoost 

func (q *MatchAllQuery) SetBoost(b float64)

type MatchNoneQuery 

type MatchNoneQuery struct {
	BoostVal *Boost `json:"boost,omitempty"`
}

func NewMatchNoneQuery 

func NewMatchNoneQuery() *MatchNoneQuery

NewMatchNoneQuery creates a Query which will not match any documents in the index.

func (*MatchNoneQuery) Boost 

func (q *MatchNoneQuery) Boost() float64

func (*MatchNoneQuery) MarshalJSON 

func (q *MatchNoneQuery) MarshalJSON() ([]byte, error)

func (*MatchNoneQuery) Searcher 

func (q *MatchNoneQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*MatchNoneQuery) SetBoost 

func (q *MatchNoneQuery) SetBoost(b float64)

type MatchPhraseQuery 

type MatchPhraseQuery struct {
	MatchPhrase string `json:"match_phrase"`
	FieldVal    string `json:"field,omitempty"`
	Analyzer    string `json:"analyzer,omitempty"`
	BoostVal    *Boost `json:"boost,omitempty"`
}

func NewMatchPhraseQuery 

func NewMatchPhraseQuery(matchPhrase string) *MatchPhraseQuery

NewMatchPhraseQuery creates a new Query object for matching phrases in the index. An Analyzer is chosen based on the field. Input text is analyzed using this analyzer. Token terms resulting from this analysis are used to build a search phrase. Result documents must match this phrase. Queried field must have been indexed with IncludeTermVectors set to true.

func (*MatchPhraseQuery) Boost 

func (q *MatchPhraseQuery) Boost() float64

func (*MatchPhraseQuery) Field 

func (q *MatchPhraseQuery) Field() string

func (*MatchPhraseQuery) Searcher 

func (q *MatchPhraseQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*MatchPhraseQuery) SetBoost 

func (q *MatchPhraseQuery) SetBoost(b float64)

func (*MatchPhraseQuery) SetField 

func (q *MatchPhraseQuery) SetField(f string)

type MatchQuery 

type MatchQuery struct {
	Match     string             `json:"match"`
	FieldVal  string             `json:"field,omitempty"`
	Analyzer  string             `json:"analyzer,omitempty"`
	BoostVal  *Boost             `json:"boost,omitempty"`
	Prefix    int                `json:"prefix_length"`
	Fuzziness int                `json:"fuzziness"`
	Operator  MatchQueryOperator `json:"operator,omitempty"`
}

func NewMatchQuery 

func NewMatchQuery(match string) *MatchQuery

NewMatchQuery creates a Query for matching text. An Analyzer is chosen based on the field. Input text is analyzed using this analyzer. Token terms resulting from this analysis are used to perform term searches. Result documents must satisfy at least one of these term searches.

func (*MatchQuery) Boost 

func (q *MatchQuery) Boost() float64

func (*MatchQuery) Field 

func (q *MatchQuery) Field() string

func (*MatchQuery) Searcher 

func (q *MatchQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*MatchQuery) SetBoost 

func (q *MatchQuery) SetBoost(b float64)

func (*MatchQuery) SetField 

func (q *MatchQuery) SetField(f string)

func (*MatchQuery) SetFuzziness 

func (q *MatchQuery) SetFuzziness(f int)

func (*MatchQuery) SetOperator 

func (q *MatchQuery) SetOperator(operator MatchQueryOperator)

func (*MatchQuery) SetPrefix 

func (q *MatchQuery) SetPrefix(p int)

type MatchQueryOperator 

type MatchQueryOperator int

func (MatchQueryOperator) MarshalJSON 

func (o MatchQueryOperator) MarshalJSON() ([]byte, error)

func (*MatchQueryOperator) UnmarshalJSON 

func (o *MatchQueryOperator) UnmarshalJSON(data []byte) error

type MultiPhraseQuery 

type MultiPhraseQuery struct {
	Terms    [][]string `json:"terms"`
	Field    string     `json:"field,omitempty"`
	BoostVal *Boost     `json:"boost,omitempty"`
}

func NewMultiPhraseQuery 

func NewMultiPhraseQuery(terms [][]string, field string) *MultiPhraseQuery

NewMultiPhraseQuery creates a new Query for finding term phrases in the index. It is like PhraseQuery, but each position in the phrase may be satisfied by a list of terms as opposed to just one. At least one of the terms must exist in the correct order, at the correct index offsets, in the specified field. Queried field must have been indexed with IncludeTermVectors set to true.

func (*MultiPhraseQuery) Boost 

func (q *MultiPhraseQuery) Boost() float64

func (*MultiPhraseQuery) Searcher 

func (q *MultiPhraseQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*MultiPhraseQuery) SetBoost 

func (q *MultiPhraseQuery) SetBoost(b float64)

func (*MultiPhraseQuery) UnmarshalJSON 

func (q *MultiPhraseQuery) UnmarshalJSON(data []byte) error

func (*MultiPhraseQuery) Validate 

func (q *MultiPhraseQuery) Validate() error

type NumericRangeQuery 

type NumericRangeQuery struct {
	Min          *float64 `json:"min,omitempty"`
	Max          *float64 `json:"max,omitempty"`
	InclusiveMin *bool    `json:"inclusive_min,omitempty"`
	InclusiveMax *bool    `json:"inclusive_max,omitempty"`
	FieldVal     string   `json:"field,omitempty"`
	BoostVal     *Boost   `json:"boost,omitempty"`
}

func NewNumericRangeInclusiveQuery 

func NewNumericRangeInclusiveQuery(min, max *float64, minInclusive, maxInclusive *bool) *NumericRangeQuery

NewNumericRangeInclusiveQuery creates a new Query for ranges of numeric values. Either, but not both endpoints can be nil. Control endpoint inclusion with inclusiveMin, inclusiveMax.

func NewNumericRangeQuery 

func NewNumericRangeQuery(min, max *float64) *NumericRangeQuery

NewNumericRangeQuery creates a new Query for ranges of numeric values. Either, but not both endpoints can be nil. The minimum value is inclusive. The maximum value is exclusive.

func (*NumericRangeQuery) Boost 

func (q *NumericRangeQuery) Boost() float64

func (*NumericRangeQuery) Field 

func (q *NumericRangeQuery) Field() string

func (*NumericRangeQuery) Searcher 

func (q *NumericRangeQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*NumericRangeQuery) SetBoost 

func (q *NumericRangeQuery) SetBoost(b float64)

func (*NumericRangeQuery) SetField 

func (q *NumericRangeQuery) SetField(f string)

func (*NumericRangeQuery) Validate 

func (q *NumericRangeQuery) Validate() error

type PhraseQuery 

type PhraseQuery struct {
	Terms    []string `json:"terms"`
	Field    string   `json:"field,omitempty"`
	BoostVal *Boost   `json:"boost,omitempty"`
}

func NewPhraseQuery 

func NewPhraseQuery(terms []string, field string) *PhraseQuery

NewPhraseQuery creates a new Query for finding exact term phrases in the index. The provided terms must exist in the correct order, at the correct index offsets, in the specified field. Queried field must have been indexed with IncludeTermVectors set to true.

func (*PhraseQuery) Boost 

func (q *PhraseQuery) Boost() float64

func (*PhraseQuery) Searcher 

func (q *PhraseQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*PhraseQuery) SetBoost 

func (q *PhraseQuery) SetBoost(b float64)

func (*PhraseQuery) UnmarshalJSON 

func (q *PhraseQuery) UnmarshalJSON(data []byte) error

func (*PhraseQuery) Validate 

func (q *PhraseQuery) Validate() error

type PrefixQuery 

type PrefixQuery struct {
	Prefix   string `json:"prefix"`
	FieldVal string `json:"field,omitempty"`
	BoostVal *Boost `json:"boost,omitempty"`
}

func NewPrefixQuery 

func NewPrefixQuery(prefix string) *PrefixQuery

NewPrefixQuery creates a new Query which finds documents containing terms that start with the specified prefix.

func (*PrefixQuery) Boost 

func (q *PrefixQuery) Boost() float64

func (*PrefixQuery) Field 

func (q *PrefixQuery) Field() string

func (*PrefixQuery) Searcher 

func (q *PrefixQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*PrefixQuery) SetBoost 

func (q *PrefixQuery) SetBoost(b float64)

func (*PrefixQuery) SetField 

func (q *PrefixQuery) SetField(f string)

type Query 

type Query interface {
	Searcher(i index.IndexReader, m mapping.IndexMapping,
		options search.SearcherOptions) (search.Searcher, error)
}

A Query represents a description of the type and parameters for a query into the index.

func ParseQuery 

func ParseQuery(input []byte) (Query, error)

ParseQuery deserializes a JSON representation of a Query object.

type QueryStringQuery 

type QueryStringQuery struct {
	Query    string `json:"query"`
	BoostVal *Boost `json:"boost,omitempty"`
}

func NewQueryStringQuery 

func NewQueryStringQuery(query string) *QueryStringQuery

NewQueryStringQuery creates a new Query used for finding documents that satisfy a query string. The query string is a small query language for humans.

func (*QueryStringQuery) Boost 

func (q *QueryStringQuery) Boost() float64

func (*QueryStringQuery) Parse 

func (q *QueryStringQuery) Parse() (Query, error)

func (*QueryStringQuery) Searcher 

func (q *QueryStringQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*QueryStringQuery) SetBoost 

func (q *QueryStringQuery) SetBoost(b float64)

func (*QueryStringQuery) Validate 

func (q *QueryStringQuery) Validate() error

type RegexpQuery 

type RegexpQuery struct {
	Regexp   string `json:"regexp"`
	FieldVal string `json:"field,omitempty"`
	BoostVal *Boost `json:"boost,omitempty"`
}

func NewRegexpQuery 

func NewRegexpQuery(regexp string) *RegexpQuery

NewRegexpQuery creates a new Query which finds documents containing terms that match the specified regular expression. The regexp pattern SHOULD NOT include ^ or $ modifiers, the search will only match entire terms even without them.

func (*RegexpQuery) Boost 

func (q *RegexpQuery) Boost() float64

func (*RegexpQuery) Field 

func (q *RegexpQuery) Field() string

func (*RegexpQuery) Searcher 

func (q *RegexpQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*RegexpQuery) SetBoost 

func (q *RegexpQuery) SetBoost(b float64)

func (*RegexpQuery) SetField 

func (q *RegexpQuery) SetField(f string)

func (*RegexpQuery) Validate 

func (q *RegexpQuery) Validate() error

type TermQuery 

type TermQuery struct {
	Term     string `json:"term"`
	FieldVal string `json:"field,omitempty"`
	BoostVal *Boost `json:"boost,omitempty"`
}

func NewTermQuery 

func NewTermQuery(term string) *TermQuery

NewTermQuery creates a new Query for finding an exact term match in the index.

func (*TermQuery) Boost 

func (q *TermQuery) Boost() float64

func (*TermQuery) Field 

func (q *TermQuery) Field() string

func (*TermQuery) Searcher 

func (q *TermQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*TermQuery) SetBoost 

func (q *TermQuery) SetBoost(b float64)

func (*TermQuery) SetField 

func (q *TermQuery) SetField(f string)

type TermRangeQuery 

type TermRangeQuery struct {
	Min          string `json:"min,omitempty"`
	Max          string `json:"max,omitempty"`
	InclusiveMin *bool  `json:"inclusive_min,omitempty"`
	InclusiveMax *bool  `json:"inclusive_max,omitempty"`
	FieldVal     string `json:"field,omitempty"`
	BoostVal     *Boost `json:"boost,omitempty"`
}

func NewTermRangeInclusiveQuery 

func NewTermRangeInclusiveQuery(min, max string, minInclusive, maxInclusive *bool) *TermRangeQuery

NewTermRangeInclusiveQuery creates a new Query for ranges of numeric values. Either, but not both endpoints can be nil. Control endpoint inclusion with inclusiveMin, inclusiveMax.

func NewTermRangeQuery 

func NewTermRangeQuery(min, max string) *TermRangeQuery

NewTermRangeQuery creates a new Query for ranges of text term values. Either, but not both endpoints can be nil. The minimum value is inclusive. The maximum value is exclusive.

func (*TermRangeQuery) Boost 

func (q *TermRangeQuery) Boost() float64

func (*TermRangeQuery) Field 

func (q *TermRangeQuery) Field() string

func (*TermRangeQuery) Searcher 

func (q *TermRangeQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*TermRangeQuery) SetBoost 

func (q *TermRangeQuery) SetBoost(b float64)

func (*TermRangeQuery) SetField 

func (q *TermRangeQuery) SetField(f string)

func (*TermRangeQuery) Validate 

func (q *TermRangeQuery) Validate() error

type ValidatableQuery 

type ValidatableQuery interface {
	Query
	Validate() error
}

A ValidatableQuery represents a Query which can be validated prior to execution.

type WildcardQuery 

type WildcardQuery struct {
	Wildcard string `json:"wildcard"`
	FieldVal string `json:"field,omitempty"`
	BoostVal *Boost `json:"boost,omitempty"`
}

func NewWildcardQuery 

func NewWildcardQuery(wildcard string) *WildcardQuery

NewWildcardQuery creates a new Query which finds documents containing terms that match the specified wildcard. In the wildcard pattern '*' will match any sequence of 0 or more characters, and '?' will match any single character.

func (*WildcardQuery) Boost 

func (q *WildcardQuery) Boost() float64

func (*WildcardQuery) Field 

func (q *WildcardQuery) Field() string

func (*WildcardQuery) Searcher 

func (q *WildcardQuery) Searcher(i index.IndexReader, m mapping.IndexMapping, options search.SearcherOptions) (search.Searcher, error)

func (*WildcardQuery) SetBoost 

func (q *WildcardQuery) SetBoost(b float64)

func (*WildcardQuery) SetField 

func (q *WildcardQuery) SetField(f string)

func (*WildcardQuery) Validate 

func (q *WildcardQuery) Validate() error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.