Copyright | (C) 2014 Chris Allen |
---|---|
License | BSD-style (see the file LICENSE) |
Maintainer | Chris Allen <cma@bitemyapp.com |
Stability | provisional |
Portability | DeriveGeneric, RecordWildCards |
Safe Haskell | None |
Language | Haskell2010 |
Data types for describing actions and data structures performed to interact
with Elasticsearch. The two main buckets your queries against Elasticsearch
will fall into are Query
s and Filter
s. Filter
s are more like
traditional database constraints and often have preferable performance
properties. Query
s support human-written textual queries, such as fuzzy
queries.
- defaultCache :: Cache
- defaultIndexSettings :: IndexSettings
- defaultIndexDocumentSettings :: IndexDocumentSettings
- mkSort :: FieldName -> SortOrder -> DefaultSort
- showText :: Show a => a -> Text
- unpackId :: DocId -> Text
- mkMatchQuery :: FieldName -> QueryString -> MatchQuery
- mkMultiMatchQuery :: [FieldName] -> QueryString -> MultiMatchQuery
- mkBoolQuery :: [Query] -> [Query] -> [Query] -> BoolQuery
- mkRangeQuery :: FieldName -> RangeValue -> RangeQuery
- mkQueryStringQuery :: QueryString -> QueryStringQuery
- mkAggregations :: Text -> Aggregation -> Aggregations
- mkTermsAggregation :: Text -> TermsAggregation
- mkTermsScriptAggregation :: Text -> TermsAggregation
- mkDateHistogram :: FieldName -> Interval -> DateHistogramAggregation
- mkDocVersion :: Int -> Maybe DocVersion
- docVersionNumber :: DocVersion -> Int
- toTerms :: Text -> AggregationResults -> Maybe (Bucket TermsResult)
- toDateHistogram :: Text -> AggregationResults -> Maybe (Bucket DateHistogramResult)
- omitNulls :: [(Text, Value)] -> Value
- newtype BH m a = BH {}
- runBH :: BHEnv -> BH m a -> m a
- data BHEnv = BHEnv {}
- class (Functor m, Applicative m, MonadIO m) => MonadBH m where
- data Version = Version {}
- data Status = Status {}
- newtype Existence = Existence Bool
- newtype NullValue = NullValue Bool
- data IndexSettings = IndexSettings {}
- data IndexTemplate = IndexTemplate {}
- newtype Server = Server Text
- type Reply = Response ByteString
- data EsResult a = EsResult {
- _index :: Text
- _type :: Text
- _id :: Text
- foundResult :: Maybe (EsResultFound a)
- data EsResultFound a = EsResultFound {
- _version :: DocVersion
- _source :: a
- data DocVersion
- newtype ExternalDocVersion = ExternalDocVersion DocVersion
- data VersionControl
- newtype DocumentParent = DocumentParent DocId
- data IndexDocumentSettings = IndexDocumentSettings {}
- data Query
- = TermQuery Term (Maybe Boost)
- | TermsQuery (NonEmpty Term)
- | QueryMatchQuery MatchQuery
- | QueryMultiMatchQuery MultiMatchQuery
- | QueryBoolQuery BoolQuery
- | QueryBoostingQuery BoostingQuery
- | QueryCommonTermsQuery CommonTermsQuery
- | ConstantScoreFilter Filter Boost
- | ConstantScoreQuery Query Boost
- | QueryDisMaxQuery DisMaxQuery
- | QueryFilteredQuery FilteredQuery
- | QueryFuzzyLikeThisQuery FuzzyLikeThisQuery
- | QueryFuzzyLikeFieldQuery FuzzyLikeFieldQuery
- | QueryFuzzyQuery FuzzyQuery
- | QueryHasChildQuery HasChildQuery
- | QueryHasParentQuery HasParentQuery
- | IdsQuery MappingName [DocId]
- | QueryIndicesQuery IndicesQuery
- | MatchAllQuery (Maybe Boost)
- | QueryMoreLikeThisQuery MoreLikeThisQuery
- | QueryMoreLikeThisFieldQuery MoreLikeThisFieldQuery
- | QueryNestedQuery NestedQuery
- | QueryPrefixQuery PrefixQuery
- | QueryQueryStringQuery QueryStringQuery
- | QuerySimpleQueryStringQuery SimpleQueryStringQuery
- | QueryRangeQuery RangeQuery
- | QueryRegexpQuery RegexpQuery
- data Search = Search {
- queryBody :: Maybe Query
- filterBody :: Maybe Filter
- sortBody :: Maybe Sort
- aggBody :: Maybe Aggregations
- highlight :: Maybe Highlights
- trackSortScores :: TrackSortScores
- from :: From
- size :: Size
- searchType :: SearchType
- fields :: Maybe [FieldName]
- source :: Maybe Source
- data SearchType
- data SearchResult a = SearchResult {
- took :: Int
- timedOut :: Bool
- shards :: ShardResult
- searchHits :: SearchHits a
- aggregations :: Maybe AggregationResults
- scrollId :: Maybe ScrollId
- type ScrollId = Text
- data SearchHits a = SearchHits {}
- type TrackSortScores = Bool
- newtype From = From Int
- newtype Size = Size Int
- data Source
- data PatternOrPatterns
- data Include = Include [Pattern]
- data Exclude = Exclude [Pattern]
- newtype Pattern = Pattern Text
- data ShardResult = ShardResult {
- shardTotal :: Int
- shardsSuccessful :: Int
- shardsFailed :: Int
- data Hit a = Hit {
- hitIndex :: IndexName
- hitType :: MappingName
- hitDocId :: DocId
- hitScore :: Score
- hitSource :: a
- hitHighlight :: Maybe HitHighlight
- data Filter
- = AndFilter [Filter] Cache
- | OrFilter [Filter] Cache
- | NotFilter Filter Cache
- | IdentityFilter
- | BoolFilter BoolMatch
- | ExistsFilter FieldName
- | GeoBoundingBoxFilter GeoBoundingBoxConstraint
- | GeoDistanceFilter GeoPoint Distance DistanceType OptimizeBbox Cache
- | GeoDistanceRangeFilter GeoPoint DistanceRange
- | GeoPolygonFilter FieldName [LatLon]
- | IdsFilter MappingName [DocId]
- | LimitFilter Int
- | MissingFilter FieldName Existence NullValue
- | PrefixFilter FieldName PrefixValue Cache
- | QueryFilter Query Cache
- | RangeFilter FieldName RangeValue RangeExecution Cache
- | RegexpFilter FieldName Regexp RegexpFlags CacheName Cache CacheKey
- | TermFilter Term Cache
- class Monoid a => Seminearring a where
- data BoolMatch
- data Term = Term {}
- data GeoPoint = GeoPoint {}
- data GeoBoundingBoxConstraint = GeoBoundingBoxConstraint {}
- data GeoBoundingBox = GeoBoundingBox {
- topLeft :: LatLon
- bottomRight :: LatLon
- data GeoFilterType
- data Distance = Distance {}
- data DistanceUnit
- = Miles
- | Yards
- | Feet
- | Inches
- | Kilometers
- | Meters
- | Centimeters
- | Millimeters
- | NauticalMiles
- data DistanceType
- data DistanceRange = DistanceRange {}
- data OptimizeBbox
- data LatLon = LatLon {}
- data RangeValue
- = RangeDateLte LessThanEqD
- | RangeDateLt LessThanD
- | RangeDateGte GreaterThanEqD
- | RangeDateGt GreaterThanD
- | RangeDateGtLt GreaterThanD LessThanD
- | RangeDateGteLte GreaterThanEqD LessThanEqD
- | RangeDateGteLt GreaterThanEqD LessThanD
- | RangeDateGtLte GreaterThanD LessThanEqD
- | RangeDoubleLte LessThanEq
- | RangeDoubleLt LessThan
- | RangeDoubleGte GreaterThanEq
- | RangeDoubleGt GreaterThan
- | RangeDoubleGtLt GreaterThan LessThan
- | RangeDoubleGteLte GreaterThanEq LessThanEq
- | RangeDoubleGteLt GreaterThanEq LessThan
- | RangeDoubleGtLte GreaterThan LessThanEq
- data RangeExecution
- newtype LessThan = LessThan Double
- newtype LessThanEq = LessThanEq Double
- newtype GreaterThan = GreaterThan Double
- newtype GreaterThanEq = GreaterThanEq Double
- newtype LessThanD = LessThanD UTCTime
- newtype LessThanEqD = LessThanEqD UTCTime
- newtype GreaterThanD = GreaterThanD UTCTime
- newtype GreaterThanEqD = GreaterThanEqD UTCTime
- newtype Regexp = Regexp Text
- data RegexpFlags
- data RegexpFlag
- newtype FieldName = FieldName Text
- newtype Script = Script {
- scriptText :: Text
- newtype IndexName = IndexName Text
- newtype TemplateName = TemplateName Text
- newtype TemplatePattern = TemplatePattern Text
- newtype MappingName = MappingName Text
- newtype DocId = DocId Text
- newtype CacheName = CacheName Text
- newtype CacheKey = CacheKey Text
- data BulkOperation
- newtype ReplicaCount = ReplicaCount Int
- newtype ShardCount = ShardCount Int
- type Sort = [SortSpec]
- data SortMode
- data SortOrder
- data SortSpec
- data DefaultSort = DefaultSort {}
- data Missing
- data OpenCloseIndex
- type Method = Method
- newtype Boost = Boost Double
- data MatchQuery = MatchQuery {
- matchQueryField :: FieldName
- matchQueryQueryString :: QueryString
- matchQueryOperator :: BooleanOperator
- matchQueryZeroTerms :: ZeroTermsQuery
- matchQueryCutoffFrequency :: Maybe CutoffFrequency
- matchQueryMatchType :: Maybe MatchQueryType
- matchQueryAnalyzer :: Maybe Analyzer
- matchQueryMaxExpansions :: Maybe MaxExpansions
- matchQueryLenient :: Maybe Lenient
- matchQueryBoost :: Maybe Boost
- data MultiMatchQuery = MultiMatchQuery {
- multiMatchQueryFields :: [FieldName]
- multiMatchQueryString :: QueryString
- multiMatchQueryOperator :: BooleanOperator
- multiMatchQueryZeroTerms :: ZeroTermsQuery
- multiMatchQueryTiebreaker :: Maybe Tiebreaker
- multiMatchQueryType :: Maybe MultiMatchQueryType
- multiMatchQueryCutoffFrequency :: Maybe CutoffFrequency
- multiMatchQueryAnalyzer :: Maybe Analyzer
- multiMatchQueryMaxExpansions :: Maybe MaxExpansions
- multiMatchQueryLenient :: Maybe Lenient
- data BoolQuery = BoolQuery {}
- data BoostingQuery = BoostingQuery {}
- data CommonTermsQuery = CommonTermsQuery {
- commonField :: FieldName
- commonQuery :: QueryString
- commonCutoffFrequency :: CutoffFrequency
- commonLowFreqOperator :: BooleanOperator
- commonHighFreqOperator :: BooleanOperator
- commonMinimumShouldMatch :: Maybe CommonMinimumMatch
- commonBoost :: Maybe Boost
- commonAnalyzer :: Maybe Analyzer
- commonDisableCoord :: Maybe DisableCoord
- data DisMaxQuery = DisMaxQuery {}
- data FilteredQuery = FilteredQuery {}
- data FuzzyLikeThisQuery = FuzzyLikeThisQuery {}
- data FuzzyLikeFieldQuery = FuzzyLikeFieldQuery {}
- data FuzzyQuery = FuzzyQuery {}
- data HasChildQuery = HasChildQuery {}
- data HasParentQuery = HasParentQuery {}
- data IndicesQuery = IndicesQuery {}
- data MoreLikeThisQuery = MoreLikeThisQuery {
- moreLikeThisText :: Text
- moreLikeThisFields :: Maybe [FieldName]
- moreLikeThisPercentMatch :: Maybe PercentMatch
- moreLikeThisMinimumTermFreq :: Maybe MinimumTermFrequency
- moreLikeThisMaxQueryTerms :: Maybe MaxQueryTerms
- moreLikeThisStopWords :: Maybe [StopWord]
- moreLikeThisMinDocFrequency :: Maybe MinDocFrequency
- moreLikeThisMaxDocFrequency :: Maybe MaxDocFrequency
- moreLikeThisMinWordLength :: Maybe MinWordLength
- moreLikeThisMaxWordLength :: Maybe MaxWordLength
- moreLikeThisBoostTerms :: Maybe BoostTerms
- moreLikeThisBoost :: Maybe Boost
- moreLikeThisAnalyzer :: Maybe Analyzer
- data MoreLikeThisFieldQuery = MoreLikeThisFieldQuery {
- moreLikeThisFieldText :: Text
- moreLikeThisFieldFields :: FieldName
- moreLikeThisFieldPercentMatch :: Maybe PercentMatch
- moreLikeThisFieldMinimumTermFreq :: Maybe MinimumTermFrequency
- moreLikeThisFieldMaxQueryTerms :: Maybe MaxQueryTerms
- moreLikeThisFieldStopWords :: Maybe [StopWord]
- moreLikeThisFieldMinDocFrequency :: Maybe MinDocFrequency
- moreLikeThisFieldMaxDocFrequency :: Maybe MaxDocFrequency
- moreLikeThisFieldMinWordLength :: Maybe MinWordLength
- moreLikeThisFieldMaxWordLength :: Maybe MaxWordLength
- moreLikeThisFieldBoostTerms :: Maybe BoostTerms
- moreLikeThisFieldBoost :: Maybe Boost
- moreLikeThisFieldAnalyzer :: Maybe Analyzer
- data NestedQuery = NestedQuery {}
- data PrefixQuery = PrefixQuery {}
- data QueryStringQuery = QueryStringQuery {
- queryStringQuery :: QueryString
- queryStringDefaultField :: Maybe FieldName
- queryStringOperator :: Maybe BooleanOperator
- queryStringAnalyzer :: Maybe Analyzer
- queryStringAllowLeadingWildcard :: Maybe AllowLeadingWildcard
- queryStringLowercaseExpanded :: Maybe LowercaseExpanded
- queryStringEnablePositionIncrements :: Maybe EnablePositionIncrements
- queryStringFuzzyMaxExpansions :: Maybe MaxExpansions
- queryStringFuzziness :: Maybe Fuzziness
- queryStringFuzzyPrefixLength :: Maybe PrefixLength
- queryStringPhraseSlop :: Maybe PhraseSlop
- queryStringBoost :: Maybe Boost
- queryStringAnalyzeWildcard :: Maybe AnalyzeWildcard
- queryStringGeneratePhraseQueries :: Maybe GeneratePhraseQueries
- queryStringMinimumShouldMatch :: Maybe MinimumMatch
- queryStringLenient :: Maybe Lenient
- queryStringLocale :: Maybe Locale
- data SimpleQueryStringQuery = SimpleQueryStringQuery {
- simpleQueryStringQuery :: QueryString
- simpleQueryStringField :: Maybe FieldOrFields
- simpleQueryStringOperator :: Maybe BooleanOperator
- simpleQueryStringAnalyzer :: Maybe Analyzer
- simpleQueryStringFlags :: Maybe [SimpleQueryFlag]
- simpleQueryStringLowercaseExpanded :: Maybe LowercaseExpanded
- simpleQueryStringLocale :: Maybe Locale
- data RangeQuery = RangeQuery {}
- data RegexpQuery = RegexpQuery {}
- newtype QueryString = QueryString Text
- data BooleanOperator
- data ZeroTermsQuery
- newtype CutoffFrequency = CutoffFrequency Double
- newtype Analyzer = Analyzer Text
- newtype MaxExpansions = MaxExpansions Int
- newtype Lenient = Lenient Bool
- data MatchQueryType
- data MultiMatchQueryType
- newtype Tiebreaker = Tiebreaker Double
- newtype MinimumMatch = MinimumMatch Int
- newtype DisableCoord = DisableCoord Bool
- data CommonMinimumMatch
- data MinimumMatchHighLow = MinimumMatchHighLow {}
- newtype PrefixLength = PrefixLength Int
- newtype Fuzziness = Fuzziness Double
- newtype IgnoreTermFrequency = IgnoreTermFrequency Bool
- newtype MaxQueryTerms = MaxQueryTerms Int
- data ScoreType
- type Score = Maybe Double
- type Cache = Bool
- newtype TypeName = TypeName Text
- newtype BoostTerms = BoostTerms Double
- newtype MaxWordLength = MaxWordLength Int
- newtype MinWordLength = MinWordLength Int
- newtype MaxDocFrequency = MaxDocFrequency Int
- newtype MinDocFrequency = MinDocFrequency Int
- newtype PhraseSlop = PhraseSlop Int
- newtype StopWord = StopWord Text
- newtype QueryPath = QueryPath Text
- newtype MinimumTermFrequency = MinimumTermFrequency Int
- newtype PercentMatch = PercentMatch Double
- data FieldDefinition = FieldDefinition {
- fieldType :: FieldType
- data MappingField = MappingField {}
- data Mapping = Mapping {}
- newtype AllowLeadingWildcard = AllowLeadingWildcard Bool
- newtype LowercaseExpanded = LowercaseExpanded Bool
- newtype GeneratePhraseQueries = GeneratePhraseQueries Bool
- newtype Locale = Locale Text
- newtype AnalyzeWildcard = AnalyzeWildcard Bool
- newtype EnablePositionIncrements = EnablePositionIncrements Bool
- data SimpleQueryFlag
- data FieldOrFields
- class Monoid a where
- class ToJSON a where
- data Interval
- data TimeInterval
- data ExecutionHint
- data CollectionMode
- data TermOrder = TermOrder {}
- data TermInclusion
- data Aggregation
- type Aggregations = Map Text Aggregation
- type AggregationResults = Map Text Value
- data Bucket a = Bucket {
- buckets :: [a]
- class BucketAggregation a where
- data TermsAggregation = TermsAggregation {
- term :: Either Text Text
- termInclude :: Maybe TermInclusion
- termExclude :: Maybe TermInclusion
- termOrder :: Maybe TermOrder
- termMinDocCount :: Maybe Int
- termSize :: Maybe Int
- termShardSize :: Maybe Int
- termCollectMode :: Maybe CollectionMode
- termExecutionHint :: Maybe ExecutionHint
- termAggs :: Maybe Aggregations
- data ValueCountAggregation
- data FilterAggregation = FilterAggregation {}
- data DateHistogramAggregation = DateHistogramAggregation {}
- data Highlights = Highlights {}
- data FieldHighlight = FieldHighlight FieldName (Maybe HighlightSettings)
- data HighlightSettings
- data PlainHighlight = PlainHighlight {}
- data PostingsHighlight = PostingsHighlight (Maybe CommonHighlight)
- data FastVectorHighlight = FastVectorHighlight {}
- data CommonHighlight = CommonHighlight {}
- data NonPostings = NonPostings {}
- data HighlightEncoder
- data HighlightTag
- = TagSchema Text
- | CustomTags ([Text], [Text])
- type HitHighlight = Map Text [Text]
- data TermsResult = TermsResult {}
- data DateHistogramResult = DateHistogramResult {}
Documentation
defaultIndexSettings :: IndexSettings Source
defaultIndexSettings
is an IndexSettings
with 3 shards and 2 replicas.
defaultIndexDocumentSettings :: IndexDocumentSettings Source
Reasonable default settings. Chooses no version control and no parent.
mkSort :: FieldName -> SortOrder -> DefaultSort Source
mkMatchQuery :: FieldName -> QueryString -> MatchQuery Source
mkMatchQuery
is a convenience function that defaults the less common parameters,
enabling you to provide only the FieldName
and QueryString
to make a MatchQuery
mkMultiMatchQuery :: [FieldName] -> QueryString -> MultiMatchQuery Source
mkMultiMatchQuery
is a convenience function that defaults the less common parameters,
enabling you to provide only the list of FieldName
s and QueryString
to
make a MultiMatchQuery
.
mkRangeQuery :: FieldName -> RangeValue -> RangeQuery Source
mkAggregations :: Text -> Aggregation -> Aggregations Source
mkDocVersion :: Int -> Maybe DocVersion Source
Smart constructor for in-range doc version
docVersionNumber :: DocVersion -> Int Source
toTerms :: Text -> AggregationResults -> Maybe (Bucket TermsResult) Source
MonadTrans BH | |
MonadError e m => MonadError e (BH m) | |
MonadReader r m => MonadReader r (BH m) | |
MonadState s m => MonadState s (BH m) | |
MonadWriter w m => MonadWriter w (BH m) | |
Alternative m => Alternative (BH m) | |
Monad m => Monad (BH m) | |
Functor m => Functor (BH m) | |
MonadFix m => MonadFix (BH m) | |
MonadPlus m => MonadPlus (BH m) | |
Applicative m => Applicative (BH m) | |
MonadThrow m => MonadThrow (BH m) | |
MonadCatch m => MonadCatch (BH m) | |
MonadMask m => MonadMask (BH m) | |
MonadIO m => MonadIO (BH m) | |
(Functor m, Applicative m, MonadIO m) => MonadBH (BH m) |
Common environment for Elasticsearch calls. Connections will be pipelined according to the provided HTTP connection manager.
class (Functor m, Applicative m, MonadIO m) => MonadBH m where Source
All API calls to Elasticsearch operate within
MonadBH. The idea is that it can be easily embedded in your
own monad transformer stack. A default instance for a ReaderT and
alias BH
is provided for the simple case.
Version | |
|
Status
is a data type for describing the JSON body returned by
Elasticsearch when you query its status. This was deprecated in 1.2.0.
data IndexSettings Source
IndexSettings
is used to configure the shards and replicas when you create
an Elasticsearch Index.
http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-create-index.html
data IndexTemplate Source
An IndexTemplate
defines a template that will automatically be
applied to new indices created. The templates include both
IndexSettings
and mappings, and a simple TemplatePattern
that
controls if the template will be applied to the index created.
Specify mappings as follows: [toJSON TweetMapping, ...]
https://www.elastic.co/guide/en/elasticsearch/reference/1.7/indices-templates.html
Server
is used with the client functions to point at the ES instance
EsResult
describes the standard wrapper JSON document that you see in
successful Elasticsearch lookups or lookups that couldn't find the document.
EsResult | |
|
data EsResultFound a Source
EsResultFound
contains the document and its metadata inside of an
EsResult
when the document was successfully found.
EsResultFound | |
|
Eq a => Eq (EsResultFound a) | |
Show a => Show (EsResultFound a) | |
FromJSON a => FromJSON (EsResultFound a) |
data DocVersion Source
DocVersion
is an integer version number for a document between 1
and 9.2e+18 used for .
newtype ExternalDocVersion Source
ExternalDocVersion
is a convenience wrapper if your code uses its
own version numbers instead of ones from ES.
data VersionControl Source
VersionControl
is specified when indexing documents as a
optimistic concurrency control.
NoVersionControl | Don't send a version. This is a pure overwrite. |
InternalVersion DocVersion | Use the default ES versioning scheme. Only index the document if the version is the same as the one specified. Only applicable to updates, as you should be getting Version from a search result. |
ExternalGT ExternalDocVersion | Use your own version numbering. Only index the document if the version is strictly higher OR the document doesn't exist. The given version will be used as the new version number for the stored document. N.B. All updates must increment this number, meaning there is some global, external ordering of updates. |
ExternalGTE ExternalDocVersion | Use your own version numbering. Only index the document if the version is equal or higher than the stored version. Will succeed if there is no existing document. The given version will be used as the new version number for the stored document. Use with care, as this could result in data loss. |
ForceVersion ExternalDocVersion | The document will always be indexed and the given version will be the new version. This is typically used for correcting errors. Use with care, as this could result in data loss. |
newtype DocumentParent Source
DocumentParent
is used to specify a parent document.
data IndexDocumentSettings Source
IndexDocumentSettings
are special settings supplied when indexing
a document. For the best backwards compatiblity when new fields are
added, you should probably prefer to start with defaultIndexDocumentSettings
Search | |
|
data SearchType Source
data SearchResult a Source
SearchResult | |
|
Eq a => Eq (SearchResult a) | |
Show a => Show (SearchResult a) | |
FromJSON a => FromJSON (SearchResult a) |
data SearchHits a Source
Eq a => Eq (SearchHits a) | |
Show a => Show (SearchHits a) | |
FromJSON a => FromJSON (SearchHits a) | |
Monoid (SearchHits a) |
type TrackSortScores = Bool Source
data PatternOrPatterns Source
data ShardResult Source
ShardResult | |
|
Hit | |
|
class Monoid a => Seminearring a where Source
data GeoBoundingBox Source
data GeoFilterType Source
data DistanceUnit Source
data DistanceRange Source
data OptimizeBbox Source
data RangeValue Source
data RangeExecution Source
data RegexpFlags Source
data RegexpFlag Source
Script
is often used in place of FieldName
to specify more
complex ways of extracting a value from a document.
Script | |
|
IndexName
is used to describe which index to querycreatedelete
newtype TemplateName Source
TemplateName
is used to describe which template to querycreatedelete
newtype TemplatePattern Source
TemplatePattern
represents a pattern which is matched against index names
newtype MappingName Source
MappingName
is part of mappings which are how ES describes and schematizes
the data in the indices.
DocId
is a generic wrapper value for expressing unique Document IDs.
Can be set by the user or created by ES itself. Often used in client
functions for poking at specific documents.
CacheName
is used in RegexpFilter
for describing the
CacheKey
keyed caching behavior.
CacheKey
is used in RegexpFilter
to key regex caching.
data BulkOperation Source
BulkOperation
is a sum type for expressing the four kinds of bulk
operation index, create, delete, and update. BulkIndex
behaves like an
"upsert", BulkCreate
will fail if a document already exists at the DocId.
http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-bulk.html#docs-bulk
newtype ReplicaCount Source
ReplicaCount
is part of IndexSettings
newtype ShardCount Source
ShardCount
is part of IndexSettings
SortMode
prescribes how to handle sorting array/multi-valued fields.
SortOrder
is Ascending
or Descending
, as you might expect. These get
encoded into "asc" or "desc" when turned into JSON.
The two main kinds of SortSpec
are DefaultSortSpec
and
GeoDistanceSortSpec
. The latter takes a SortOrder
, GeoPoint
, and
DistanceUnit
to express "nearness" to a single geographical point as a
sort specification.
data DefaultSort Source
DefaultSort
is usually the kind of SortSpec
you'll want. There's a
mkSort
convenience function for when you want to specify only the most
common parameters.
Missing
prescribes how to handle missing fields. A missing field can be
sorted last, first, or using a custom value as a substitute.
data OpenCloseIndex Source
OpenCloseIndex
is a sum type for opening and closing indices.
http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-open-close.html
data MatchQuery Source
data MultiMatchQuery Source
data BoostingQuery Source
data CommonTermsQuery Source
data DisMaxQuery Source
data FilteredQuery Source
data FuzzyLikeFieldQuery Source
data MoreLikeThisQuery Source
data MoreLikeThisFieldQuery Source
data NestedQuery Source
data QueryStringQuery Source
data SimpleQueryStringQuery Source
data RangeQuery Source
newtype QueryString Source
QueryString
is used to wrap query text bodies, be they human written or not.
data BooleanOperator Source
BooleanOperator
is the usual And/Or operators with an ES compatible
JSON encoding baked in. Used all over the place.
data ZeroTermsQuery Source
newtype CutoffFrequency Source
newtype MaxExpansions Source
Lenient
, if set to true, will cause format based failures to be
ignored. I don't know what the bloody default is, Elasticsearch
documentation didn't say what it was. Let me know if you figure it out.
data MatchQueryType Source
newtype Tiebreaker Source
newtype MinimumMatch Source
MinimumMatch
controls how many should clauses in the bool query should
match. Can be an absolute value (2) or a percentage (30%) or a
combination of both.
newtype DisableCoord Source
data CommonMinimumMatch Source
newtype PrefixLength Source
PrefixLength
is the prefix length used in queries, defaults to 0.
newtype IgnoreTermFrequency Source
newtype MaxQueryTerms Source
newtype BoostTerms Source
newtype MaxWordLength Source
newtype MinWordLength Source
newtype MaxDocFrequency Source
newtype MinDocFrequency Source
newtype PhraseSlop Source
PhraseSlop
sets the default slop for phrases, 0 means exact
phrase matches. Default is 0.
newtype MinimumTermFrequency Source
newtype PercentMatch Source
data FieldDefinition Source
FieldDefinition | |
|
data MappingField Source
Support for type reification of Mapping
s is currently incomplete, for
now the mapping API verbiage expects a ToJSON
able blob.
Indexes have mappings, mappings are schemas for the documents contained in the index. I'd recommend having only one mapping per index, always having a mapping, and keeping different kinds of documents separated if possible.
Mapping | |
|
newtype AllowLeadingWildcard Source
Allowing a wildcard at the beginning of a word (eg "*ing") is particularly
heavy, because all terms in the index need to be examined, just in case
they match. Leading wildcards can be disabled by setting
AllowLeadingWildcard
to false.
newtype LowercaseExpanded Source
newtype GeneratePhraseQueries Source
GeneratePhraseQueries
defaults to false.
Locale
is used for string conversions - defaults to ROOT.
newtype AnalyzeWildcard Source
By default, wildcard terms in a query are not analyzed.
Setting AnalyzeWildcard
to true enables best-effort analysis.
newtype EnablePositionIncrements Source
data SimpleQueryFlag Source
data FieldOrFields Source
class Monoid a where
The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:
mappend mempty x = x
mappend x mempty = x
mappend x (mappend y z) = mappend (mappend x y) z
mconcat =
foldr
mappend mempty
The method names refer to the monoid of lists under concatenation, but there are many other instances.
Minimal complete definition: mempty
and mappend
.
Some types can be viewed as a monoid in more than one way,
e.g. both addition and multiplication on numbers.
In such cases we often define newtype
s and make those instances
of Monoid
, e.g. Sum
and Product
.
mempty :: a
Identity of mappend
mappend :: a -> a -> a
An associative operation
mconcat :: [a] -> a
Fold a list using the monoid.
For most types, the default definition for mconcat
will be
used, but the function is included in the class definition so
that an optimized version can be provided for specific types.
class ToJSON a where
A type that can be converted to JSON.
An example type and instance:
@{-# LANGUAGE OverloadedStrings #-}
data Coord = Coord { x :: Double, y :: Double }
instance ToJSON Coord where
toJSON (Coord x y) = object
["x" .=
x, "y" .=
y]
@
Note the use of the OverloadedStrings
language extension which enables
Text
values to be written as string literals.
Instead of manually writing your ToJSON
instance, there are three options
to do it automatically:
- Data.Aeson.TH provides template-haskell functions which will derive an instance at compile-time. The generated instance is optimized for your type so will probably be more efficient than the following two options:
- Data.Aeson.Generic provides a generic
toJSON
function that accepts any type which is an instance ofData
. - If your compiler has support for the
DeriveGeneric
andDefaultSignatures
language extensions (GHC 7.2 and newer),toJSON
will have a default generic implementation.
To use the latter option, simply add a deriving
clause to your
datatype and declare a Generic
ToJSON
instance for your datatype without giving a
definition for toJSON
.
For example the previous example can be simplified to just:
@{-# LANGUAGE DeriveGeneric #-}
import GHC.Generics
data Coord = Coord { x :: Double, y :: Double } deriving Generic
instance ToJSON Coord @
Note that, instead of using DefaultSignatures
, it's also possible
to parameterize the generic encoding using genericToJSON
applied
to your encoding/decoding Options
:
instance ToJSON Coord where toJSON =genericToJSON
defaultOptions
Nothing
data ExecutionHint Source
data CollectionMode Source
data TermInclusion Source
data Aggregation Source
type Aggregations = Map Text Aggregation Source
type AggregationResults = Map Text Value Source
class BucketAggregation a where Source
data TermsAggregation Source
data FilterAggregation Source
Single-bucket filter aggregations. See https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-bucket-filter-aggregation.html#search-aggregations-bucket-filter-aggregation for more information.
data Highlights Source
data FieldHighlight Source
data HighlightSettings Source
data PlainHighlight Source
data PostingsHighlight Source
data CommonHighlight Source
CommonHighlight | |
|
data NonPostings Source
data HighlightEncoder Source
data HighlightTag Source
TagSchema Text | |
CustomTags ([Text], [Text]) |
type HitHighlight = Map Text [Text] Source
data TermsResult Source