git.iko.soy/typeable/bloodhound
on 26-bhenv help sign in
typeable/bloodhound/src/Database/Bloodhound/Types.hs
2166 lines 80 kB history raw
1{-# LANGUAGE DeriveGeneric #-}
2{-# LANGUAGE FlexibleContexts #-}
3{-# LANGUAGE FlexibleInstances #-}
4{-# LANGUAGE GeneralizedNewtypeDeriving #-}
5{-# LANGUAGE MultiParamTypeClasses #-}
6{-# LANGUAGE OverloadedStrings #-}
7{-# LANGUAGE RecordWildCards #-}
8{-# LANGUAGE UndecidableInstances #-}
10-------------------------------------------------------------------------------
11-- |
12-- Module : Database.Bloodhound.Types
13-- Copyright : (C) 2014 Chris Allen
14-- License : BSD-style (see the file LICENSE)
15-- Maintainer : Chris Allen <cma@bitemyapp.com
16-- Stability : provisional
17-- Portability : DeriveGeneric, RecordWildCards
18--
19-- Data types for describing actions and data structures performed to interact
20-- with Elasticsearch. The two main buckets your queries against Elasticsearch
21-- will fall into are 'Query's and 'Filter's. 'Filter's are more like
22-- traditional database constraints and often have preferable performance
23-- properties. 'Query's support human-written textual queries, such as fuzzy
24-- queries.
25-------------------------------------------------------------------------------
29module Database.Bloodhound.Types
30 ( defaultCache
31 , defaultIndexSettings
32 , mkSort
33 , showText
34 , unpackId
35 , mkMatchQuery
36 , mkMultiMatchQuery
37 , mkBoolQuery
38 , mkRangeQuery
39 , mkQueryStringQuery
40 , mkAggregations
41 , mkTermsAggregation
42 , mkTermsScriptAggregation
43 , mkDateHistogram
44 , toTerms
45 , toDateHistogram
46 , omitNulls
47 , BH
48 , runBH
49 , BHEnv(..)
50 , MonadBH(..)
51 , Version(..)
52 , Status(..)
53 , Existence(..)
54 , NullValue(..)
55 , IndexSettings(..)
56 , Server(..)
57 , Reply
58 , EsResult(..)
59 , Query(..)
60 , Search(..)
61 , SearchResult(..)
62 , SearchHits(..)
63 , TrackSortScores
64 , From(..)
65 , Size(..)
66 , ShardResult(..)
67 , Hit(..)
68 , Filter(..)
69 , Seminearring(..)
70 , BoolMatch(..)
71 , Term(..)
72 , GeoPoint(..)
73 , GeoBoundingBoxConstraint(..)
74 , GeoBoundingBox(..)
75 , GeoFilterType(..)
76 , Distance(..)
77 , DistanceUnit(..)
78 , DistanceType(..)
79 , DistanceRange(..)
80 , OptimizeBbox(..)
81 , LatLon(..)
82 , RangeValue(..)
83 , RangeExecution(..)
84 , LessThan(..)
85 , LessThanEq(..)
86 , GreaterThan(..)
87 , GreaterThanEq(..)
88 , LessThanD(..)
89 , LessThanEqD(..)
90 , GreaterThanD(..)
91 , GreaterThanEqD(..)
92 , Regexp(..)
93 , RegexpFlags(..)
94 , RegexpFlag(..)
95 , FieldName(..)
96 , IndexName(..)
97 , MappingName(..)
98 , DocId(..)
99 , CacheName(..)
100 , CacheKey(..)
101 , BulkOperation(..)
102 , ReplicaCount(..)
103 , ShardCount(..)
104 , Sort
105 , SortMode(..)
106 , SortOrder(..)
107 , SortSpec(..)
108 , DefaultSort(..)
109 , Missing(..)
110 , OpenCloseIndex(..)
111 , Method
112 , Boost(..)
113 , MatchQuery(..)
114 , MultiMatchQuery(..)
115 , BoolQuery(..)
116 , BoostingQuery(..)
117 , CommonTermsQuery(..)
118 , DisMaxQuery(..)
119 , FilteredQuery(..)
120 , FuzzyLikeThisQuery(..)
121 , FuzzyLikeFieldQuery(..)
122 , FuzzyQuery(..)
123 , HasChildQuery(..)
124 , HasParentQuery(..)
125 , IndicesQuery(..)
126 , MoreLikeThisQuery(..)
127 , MoreLikeThisFieldQuery(..)
128 , NestedQuery(..)
129 , PrefixQuery(..)
130 , QueryStringQuery(..)
131 , SimpleQueryStringQuery(..)
132 , RangeQuery(..)
133 , RegexpQuery(..)
134 , QueryString(..)
135 , BooleanOperator(..)
136 , ZeroTermsQuery(..)
137 , CutoffFrequency(..)
138 , Analyzer(..)
139 , MaxExpansions(..)
140 , Lenient(..)
141 , MatchQueryType(..)
142 , MultiMatchQueryType(..)
143 , Tiebreaker(..)
144 , MinimumMatch(..)
145 , DisableCoord(..)
146 , CommonMinimumMatch(..)
147 , MinimumMatchHighLow(..)
148 , PrefixLength(..)
149 , Fuzziness(..)
150 , IgnoreTermFrequency(..)
151 , MaxQueryTerms(..)
152 , ScoreType(..)
153 , Score
154 , Cache
155 , TypeName(..)
156 , BoostTerms(..)
157 , MaxWordLength(..)
158 , MinWordLength(..)
159 , MaxDocFrequency(..)
160 , MinDocFrequency(..)
161 , PhraseSlop(..)
162 , StopWord(..)
163 , QueryPath(..)
164 , MinimumTermFrequency(..)
165 , PercentMatch(..)
166 , FieldDefinition(..)
167 , MappingField(..)
168 , Mapping(..)
169 , AllowLeadingWildcard(..)
170 , LowercaseExpanded(..)
171 , GeneratePhraseQueries(..)
172 , Locale(..)
173 , AnalyzeWildcard(..)
174 , EnablePositionIncrements(..)
175 , SimpleQueryFlag(..)
176 , FieldOrFields(..)
177 , Monoid(..)
178 , ToJSON(..)
179 , Interval(..)
180 , TimeInterval(..)
181 , ExecutionHint(..)
182 , CollectionMode(..)
183 , TermOrder(..)
184 , TermInclusion(..)
186 , Aggregation(..)
187 , Aggregations
188 , AggregationResults
189 , Bucket(..)
190 , BucketAggregation(..)
191 , TermsAggregation(..)
192 , DateHistogramAggregation(..)
194 , Highlights(..)
195 , FieldHighlight(..)
196 , HighlightSettings(..)
197 , PlainHighlight(..)
198 , PostingsHighlight(..)
199 , FastVectorHighlight(..)
200 , CommonHighlight(..)
201 , NonPostings(..)
202 , HighlightEncoder(..)
203 , HighlightTag(..)
204 , HitHighlight
206 , TermsResult(..)
207 , DateHistogramResult(..)
208 ) where
210import Control.Applicative
211import Control.Monad.Error
212import Control.Monad.Reader
213import Control.Monad.State
214import Control.Monad.Writer
215import Data.Aeson
216import Data.Aeson.Types (Pair, emptyObject, parseMaybe)
217import qualified Data.ByteString.Lazy.Char8 as L
218import Data.List (nub)
219import Data.List.NonEmpty (NonEmpty (..), toList)
220import qualified Data.Map.Strict as M
221import Data.Text (Text)
222import qualified Data.Text as T
223import Data.Time.Clock (UTCTime)
224import qualified Data.Vector as V
225import GHC.Generics (Generic)
226import Network.HTTP.Client
227import qualified Network.HTTP.Types.Method as NHTM
229import Database.Bloodhound.Types.Class
231-- $setup
232-- >>> :set -XOverloadedStrings
233-- >>> import Database.Bloodhound
234-- >>> let testServer = (Server "http://localhost:9200")
235-- >>> let testIndex = IndexName "twitter"
236-- >>> let testMapping = MappingName "tweet"
237-- >>> let defaultIndexSettings = IndexSettings (ShardCount 3) (ReplicaCount 2)
239-- defaultIndexSettings is exported by Database.Bloodhound as well
240-- no trailing slashes in servers, library handles building the path.
242{-| Common environment for Elasticsearch calls. Connections will be
243 pipelined according to the provided HTTP connection manager.
244-}
245data BHEnv = BHEnv { bhServer :: Server
246 , bhManager :: Manager
247 }
249{-| All API calls to Elasticsearch operate within
250 MonadBH. The idea is that it can be easily embedded in your
251 own monad transformer stack. A default instance for a ReaderT and
252 alias 'BH' is provided for the simple case.
253-}
254class (Functor m, Applicative m, MonadIO m) => MonadBH m where
255 getBHEnv :: m BHEnv
257newtype BH m a = BH {
258 unBH :: ReaderT BHEnv m a
259 } deriving ( Functor
260 , Applicative
261 , Monad
262 , MonadIO
263 , MonadState s
264 , MonadWriter w
265 , MonadError e
266 , Alternative
267 , MonadPlus
268 , MonadFix)
270instance MonadTrans BH where
271 lift = BH . lift
273instance (MonadReader r m) => MonadReader r (BH m) where
274 ask = lift ask
275 local f (BH (ReaderT m)) = BH $ ReaderT $ \r ->
276 local f (m r)
278instance (Functor m, Applicative m, MonadIO m) => MonadBH (BH m) where
279 getBHEnv = BH getBHEnv
282instance (Functor m, Applicative m, MonadIO m) => MonadBH (ReaderT BHEnv m) where
283 getBHEnv = ask
285runBH :: BHEnv -> BH m a -> m a
286runBH e f = runReaderT (unBH f) e
288{-| 'Version' is embedded in 'Status' -}
289data Version = Version { number :: Text
290 , build_hash :: Text
291 , build_timestamp :: UTCTime
292 , build_snapshot :: Bool
293 , lucene_version :: Text } deriving (Eq, Show, Generic)
295{-| 'Status' is a data type for describing the JSON body returned by
296 Elasticsearch when you query its status. This was deprecated in 1.2.0.
298 <http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-status.html#indices-status>
299-}
301data Status = Status { ok :: Maybe Bool
302 , status :: Int
303 , name :: Text
304 , version :: Version
305 , tagline :: Text } deriving (Eq, Show)
307{-| 'IndexSettings' is used to configure the shards and replicas when you create
308 an Elasticsearch Index.
310 <http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-create-index.html>
311-}
313data IndexSettings =
314 IndexSettings { indexShards :: ShardCount
315 , indexReplicas :: ReplicaCount } deriving (Eq, Show)
317{-| 'defaultIndexSettings' is an 'IndexSettings' with 3 shards and 2 replicas. -}
318defaultIndexSettings :: IndexSettings
319defaultIndexSettings = IndexSettings (ShardCount 3) (ReplicaCount 2)
321{-| 'Reply' and 'Method' are type synonyms from 'Network.HTTP.Types.Method.Method' -}
322type Reply = Network.HTTP.Client.Response L.ByteString
323type Method = NHTM.Method
325{-| 'OpenCloseIndex' is a sum type for opening and closing indices.
327 <http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-open-close.html>
328-}
329data OpenCloseIndex = OpenIndex | CloseIndex deriving (Eq, Show)
331data FieldType = GeoPointType
332 | GeoShapeType
333 | FloatType
334 | IntegerType
335 | LongType
336 | ShortType
337 | ByteType deriving (Eq, Show)
339data FieldDefinition =
340 FieldDefinition { fieldType :: FieldType } deriving (Eq, Show)
342data MappingField =
343 MappingField { mappingFieldName :: FieldName
344 , fieldDefinition :: FieldDefinition } deriving (Eq, Show)
346{-| Support for type reification of 'Mapping's is currently incomplete, for
347 now the mapping API verbiage expects a 'ToJSON'able blob.
349 Indexes have mappings, mappings are schemas for the documents contained in the
350 index. I'd recommend having only one mapping per index, always having a mapping,
351 and keeping different kinds of documents separated if possible.
352-}
353data Mapping = Mapping { typeName :: TypeName
354 , mappingFields :: [MappingField] } deriving (Eq, Show)
356{-| 'BulkOperation' is a sum type for expressing the four kinds of bulk
357 operation index, create, delete, and update. 'BulkIndex' behaves like an
358 "upsert", 'BulkCreate' will fail if a document already exists at the DocId.
360 <http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-bulk.html#docs-bulk>
361-}
362data BulkOperation =
363 BulkIndex IndexName MappingName DocId Value
364 | BulkCreate IndexName MappingName DocId Value
365 | BulkDelete IndexName MappingName DocId
366 | BulkUpdate IndexName MappingName DocId Value deriving (Eq, Show)
368{-| 'EsResult' describes the standard wrapper JSON document that you see in
369 successful Elasticsearch responses.
370-}
371data EsResult a = EsResult { _index :: Text
372 , _type :: Text
373 , _id :: Text
374 , _version :: Int
375 , found :: Maybe Bool
376 , _source :: a } deriving (Eq, Show)
378{-| 'Sort' is a synonym for a list of 'SortSpec's. Sort behavior is order
379 dependent with later sorts acting as tie-breakers for earlier sorts.
380-}
381type Sort = [SortSpec]
383{-| The two main kinds of 'SortSpec' are 'DefaultSortSpec' and
384 'GeoDistanceSortSpec'. The latter takes a 'SortOrder', 'GeoPoint', and
385 'DistanceUnit' to express "nearness" to a single geographical point as a
386 sort specification.
388<http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html#search-request-sort>
389-}
390data SortSpec = DefaultSortSpec DefaultSort
391 | GeoDistanceSortSpec SortOrder GeoPoint DistanceUnit deriving (Eq, Show)
393{-| 'DefaultSort' is usually the kind of 'SortSpec' you'll want. There's a
394 'mkSort' convenience function for when you want to specify only the most
395 common parameters.
397<http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html#search-request-sort>
398-}
399data DefaultSort =
400 DefaultSort { sortFieldName :: FieldName
401 , sortOrder :: SortOrder
402 -- default False
403 , ignoreUnmapped :: Bool
404 , sortMode :: Maybe SortMode
405 , missingSort :: Maybe Missing
406 , nestedFilter :: Maybe Filter } deriving (Eq, Show)
408{-| 'SortOrder' is 'Ascending' or 'Descending', as you might expect. These get
409 encoded into "asc" or "desc" when turned into JSON.
411<http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html#search-request-sort>
412-}
413data SortOrder = Ascending
414 | Descending deriving (Eq, Show)
416{-| 'Missing' prescribes how to handle missing fields. A missing field can be
417 sorted last, first, or using a custom value as a substitute.
419<http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html#_missing_values>
420-}
421data Missing = LastMissing
422 | FirstMissing
423 | CustomMissing Text deriving (Eq, Show)
425{-| 'SortMode' prescribes how to handle sorting array/multi-valued fields.
427http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html#_sort_mode_option
428-}
429data SortMode = SortMin
430 | SortMax
431 | SortSum
432 | SortAvg deriving (Eq, Show)
434{-| 'mkSort' defaults everything but the 'FieldName' and the 'SortOrder' so
435 that you can concisely describe the usual kind of 'SortSpec's you want.
436-}
437mkSort :: FieldName -> SortOrder -> DefaultSort
438mkSort fieldName sOrder = DefaultSort fieldName sOrder False Nothing Nothing Nothing
440{-| 'Cache' is for telling ES whether it should cache a 'Filter' not.
441 'Query's cannot be cached.
442-}
443type Cache = Bool -- caching on/off
444defaultCache :: Cache
445defaultCache = False
447{-| 'PrefixValue' is used in 'PrefixQuery' as the main query component.
448-}
449type PrefixValue = Text
451{-| 'BooleanOperator' is the usual And/Or operators with an ES compatible
452 JSON encoding baked in. Used all over the place.
453-}
454data BooleanOperator = And | Or deriving (Eq, Show)
456{-| 'ShardCount' is part of 'IndexSettings'
457-}
458newtype ShardCount = ShardCount Int deriving (Eq, Show, Generic)
460{-| 'ReplicaCount' is part of 'IndexSettings'
461-}
462newtype ReplicaCount = ReplicaCount Int deriving (Eq, Show, Generic)
464{-| 'Server' is used with the client functions to point at the ES instance
465-}
466newtype Server = Server Text deriving (Eq, Show)
468{-| 'IndexName' is used to describe which index to query/create/delete
469-}
470newtype IndexName = IndexName Text deriving (Eq, Generic, Show)
472{-| 'MappingName' is part of mappings which are how ES describes and schematizes
473 the data in the indices.
474-}
475newtype MappingName = MappingName Text deriving (Eq, Generic, Show)
477{-| 'DocId' is a generic wrapper value for expressing unique Document IDs.
478 Can be set by the user or created by ES itself. Often used in client
479 functions for poking at specific documents.
480-}
481newtype DocId = DocId Text deriving (Eq, Generic, Show)
483{-| 'QueryString' is used to wrap query text bodies, be they human written or not.
484-}
485newtype QueryString = QueryString Text deriving (Eq, Generic, Show)
487{-| 'FieldName' is used all over the place wherever a specific field within
488 a document needs to be specified, usually in 'Query's or 'Filter's.
489-}
490newtype FieldName = FieldName Text deriving (Eq, Show)
492{-| 'CacheName' is used in 'RegexpFilter' for describing the
493 'CacheKey' keyed caching behavior.
494-}
495newtype CacheName = CacheName Text deriving (Eq, Show)
497{-| 'CacheKey' is used in 'RegexpFilter' to key regex caching.
498-}
499newtype CacheKey =
500 CacheKey Text deriving (Eq, Show)
501newtype Existence =
502 Existence Bool deriving (Eq, Show)
503newtype NullValue =
504 NullValue Bool deriving (Eq, Show)
505newtype CutoffFrequency =
506 CutoffFrequency Double deriving (Eq, Show, Generic)
507newtype Analyzer =
508 Analyzer Text deriving (Eq, Show, Generic)
509newtype MaxExpansions =
510 MaxExpansions Int deriving (Eq, Show, Generic)
512{-| 'Lenient', if set to true, will cause format based failures to be
513 ignored. I don't know what the bloody default is, Elasticsearch
514 documentation didn't say what it was. Let me know if you figure it out.
515-}
516newtype Lenient =
517 Lenient Bool deriving (Eq, Show, Generic)
518newtype Tiebreaker =
519 Tiebreaker Double deriving (Eq, Show, Generic)
520newtype Boost =
521 Boost Double deriving (Eq, Show, Generic)
522newtype BoostTerms =
523 BoostTerms Double deriving (Eq, Show, Generic)
525{-| 'MinimumMatch' controls how many should clauses in the bool query should
526 match. Can be an absolute value (2) or a percentage (30%) or a
527 combination of both.
528-}
529newtype MinimumMatch =
530 MinimumMatch Int deriving (Eq, Show, Generic)
531newtype MinimumMatchText =
532 MinimumMatchText Text deriving (Eq, Show)
533newtype DisableCoord =
534 DisableCoord Bool deriving (Eq, Show, Generic)
535newtype IgnoreTermFrequency =
536 IgnoreTermFrequency Bool deriving (Eq, Show, Generic)
537newtype MinimumTermFrequency =
538 MinimumTermFrequency Int deriving (Eq, Show, Generic)
539newtype MaxQueryTerms =
540 MaxQueryTerms Int deriving (Eq, Show, Generic)
541newtype Fuzziness =
542 Fuzziness Double deriving (Eq, Show, Generic)
544{-| 'PrefixLength' is the prefix length used in queries, defaults to 0. -}
545newtype PrefixLength =
546 PrefixLength Int deriving (Eq, Show, Generic)
547newtype TypeName =
548 TypeName Text deriving (Eq, Show, Generic)
549newtype PercentMatch =
550 PercentMatch Double deriving (Eq, Show, Generic)
551newtype StopWord =
552 StopWord Text deriving (Eq, Show, Generic)
553newtype QueryPath =
554 QueryPath Text deriving (Eq, Show, Generic)
556{-| Allowing a wildcard at the beginning of a word (eg "*ing") is particularly
557 heavy, because all terms in the index need to be examined, just in case
558 they match. Leading wildcards can be disabled by setting
559 'AllowLeadingWildcard' to false. -}
560newtype AllowLeadingWildcard =
561 AllowLeadingWildcard Bool deriving (Eq, Show, Generic)
562newtype LowercaseExpanded =
563 LowercaseExpanded Bool deriving (Eq, Show, Generic)
564newtype EnablePositionIncrements =
565 EnablePositionIncrements Bool deriving (Eq, Show, Generic)
567{-| By default, wildcard terms in a query are not analyzed.
568 Setting 'AnalyzeWildcard' to true enables best-effort analysis.
569-}
570newtype AnalyzeWildcard = AnalyzeWildcard Bool deriving (Eq, Show, Generic)
572{-| 'GeneratePhraseQueries' defaults to false.
573-}
574newtype GeneratePhraseQueries =
575 GeneratePhraseQueries Bool deriving (Eq, Show, Generic)
577{-| 'Locale' is used for string conversions - defaults to ROOT.
578-}
579newtype Locale = Locale Text deriving (Eq, Show, Generic)
580newtype MaxWordLength = MaxWordLength Int deriving (Eq, Show, Generic)
581newtype MinWordLength = MinWordLength Int deriving (Eq, Show, Generic)
583{-| 'PhraseSlop' sets the default slop for phrases, 0 means exact
584 phrase matches. Default is 0.
585-}
586newtype PhraseSlop = PhraseSlop Int deriving (Eq, Show, Generic)
587newtype MinDocFrequency = MinDocFrequency Int deriving (Eq, Show, Generic)
588newtype MaxDocFrequency = MaxDocFrequency Int deriving (Eq, Show, Generic)
590{-| 'unpackId' is a silly convenience function that gets used once.
591-}
592unpackId :: DocId -> Text
593unpackId (DocId docId) = docId
595type TrackSortScores = Bool
596newtype From = From Int deriving (Eq, Show, ToJSON)
597newtype Size = Size Int deriving (Eq, Show, ToJSON)
599data Search = Search { queryBody :: Maybe Query
600 , filterBody :: Maybe Filter
601 , sortBody :: Maybe Sort
602 , aggBody :: Maybe Aggregations
603 , highlight :: Maybe Highlights
604 -- default False
605 , trackSortScores :: TrackSortScores
606 , from :: From
607 , size :: Size } deriving (Eq, Show)
609data Highlights = Highlights { globalsettings :: Maybe HighlightSettings
610 , highlightFields :: [FieldHighlight]
611 } deriving (Show, Eq)
613data FieldHighlight = FieldHighlight FieldName (Maybe HighlightSettings)
614 deriving (Show, Eq)
617data HighlightSettings = Plain PlainHighlight
618 | Postings PostingsHighlight
619 | FastVector FastVectorHighlight
620 deriving (Show, Eq)
621data PlainHighlight =
622 PlainHighlight { plainCommon :: Maybe CommonHighlight
623 , plainNonPost :: Maybe NonPostings } deriving (Show, Eq)
625 -- This requires that index_options are set to 'offset' in the mapping.
626data PostingsHighlight = PostingsHighlight (Maybe CommonHighlight) deriving (Show, Eq)
628-- This requires that term_vector is set to 'with_positions_offsets' in the mapping.
629data FastVectorHighlight =
630 FastVectorHighlight { fvCommon :: Maybe CommonHighlight
631 , fvNonPostSettings :: Maybe NonPostings
632 , boundaryChars :: Maybe Text
633 , boundaryMaxScan :: Maybe Int
634 , fragmentOffset :: Maybe Int
635 , matchedFields :: [Text]
636 , phraseLimit :: Maybe Int
637 } deriving (Show, Eq)
639data CommonHighlight =
640 CommonHighlight { order :: Maybe Text
641 , forceSource :: Maybe Bool
642 , tag :: Maybe HighlightTag
643 , encoder :: Maybe HighlightEncoder
644 , noMatchSize :: Maybe Int
645 , highlightQuery :: Maybe Query
646 , requireFieldMatch :: Maybe Bool
647 } deriving (Show, Eq)
649-- Settings that are only applicable to FastVector and Plain highlighters.
650data NonPostings =
651 NonPostings { fragmentSize :: Maybe Int
652 , numberOfFragments :: Maybe Int} deriving (Show, Eq)
654data HighlightEncoder = DefaultEncoder
655 | HTMLEncoder
656 deriving (Show, Eq)
658-- NOTE: Should the tags use some kind of HTML type, rather than Text?
659data HighlightTag = TagSchema Text
660 | CustomTags ([Text], [Text]) -- Only uses more than the first value in the lists if fvh
661 deriving (Show, Eq)
664data Query =
665 TermQuery Term (Maybe Boost)
666 | TermsQuery (NonEmpty Term)
667 | QueryMatchQuery MatchQuery
668 | QueryMultiMatchQuery MultiMatchQuery
669 | QueryBoolQuery BoolQuery
670 | QueryBoostingQuery BoostingQuery
671 | QueryCommonTermsQuery CommonTermsQuery
672 | ConstantScoreFilter Filter Boost
673 | ConstantScoreQuery Query Boost
674 | QueryDisMaxQuery DisMaxQuery
675 | QueryFilteredQuery FilteredQuery
676 | QueryFuzzyLikeThisQuery FuzzyLikeThisQuery
677 | QueryFuzzyLikeFieldQuery FuzzyLikeFieldQuery
678 | QueryFuzzyQuery FuzzyQuery
679 | QueryHasChildQuery HasChildQuery
680 | QueryHasParentQuery HasParentQuery
681 | IdsQuery MappingName [DocId]
682 | QueryIndicesQuery IndicesQuery
683 | MatchAllQuery (Maybe Boost)
684 | QueryMoreLikeThisQuery MoreLikeThisQuery
685 | QueryMoreLikeThisFieldQuery MoreLikeThisFieldQuery
686 | QueryNestedQuery NestedQuery
687 | QueryPrefixQuery PrefixQuery
688 | QueryQueryStringQuery QueryStringQuery
689 | QuerySimpleQueryStringQuery SimpleQueryStringQuery
690 | QueryRangeQuery RangeQuery
691 | QueryRegexpQuery RegexpQuery
692 deriving (Eq, Show)
694data RegexpQuery =
695 RegexpQuery { regexpQueryField :: FieldName
696 , regexpQuery :: Regexp
697 , regexpQueryFlags :: RegexpFlags
698 , regexpQueryBoost :: Maybe Boost
699 } deriving (Eq, Show)
701data RangeQuery =
702 RangeQuery { rangeQueryField :: FieldName
703 , rangeQueryRange :: RangeValue
704 , rangeQueryBoost :: Boost } deriving (Eq, Show)
706mkRangeQuery :: FieldName -> RangeValue -> RangeQuery
707mkRangeQuery f r = RangeQuery f r (Boost 1.0)
709data SimpleQueryStringQuery =
710 SimpleQueryStringQuery
711 { simpleQueryStringQuery :: QueryString
712 , simpleQueryStringField :: Maybe FieldOrFields
713 , simpleQueryStringOperator :: Maybe BooleanOperator
714 , simpleQueryStringAnalyzer :: Maybe Analyzer
715 , simpleQueryStringFlags :: Maybe [SimpleQueryFlag]
716 , simpleQueryStringLowercaseExpanded :: Maybe LowercaseExpanded
717 , simpleQueryStringLocale :: Maybe Locale
718 } deriving (Eq, Show)
720data SimpleQueryFlag =
721 SimpleQueryAll
722 | SimpleQueryNone
723 | SimpleQueryAnd
724 | SimpleQueryOr
725 | SimpleQueryPrefix
726 | SimpleQueryPhrase
727 | SimpleQueryPrecedence
728 | SimpleQueryEscape
729 | SimpleQueryWhitespace
730 | SimpleQueryFuzzy
731 | SimpleQueryNear
732 | SimpleQuerySlop deriving (Eq, Show)
734-- use_dis_max and tie_breaker when fields are plural?
735data QueryStringQuery =
736 QueryStringQuery
737 { queryStringQuery :: QueryString
738 , queryStringDefaultField :: Maybe FieldName
739 , queryStringOperator :: Maybe BooleanOperator
740 , queryStringAnalyzer :: Maybe Analyzer
741 , queryStringAllowLeadingWildcard :: Maybe AllowLeadingWildcard
742 , queryStringLowercaseExpanded :: Maybe LowercaseExpanded
743 , queryStringEnablePositionIncrements :: Maybe EnablePositionIncrements
744 , queryStringFuzzyMaxExpansions :: Maybe MaxExpansions
745 , queryStringFuzziness :: Maybe Fuzziness
746 , queryStringFuzzyPrefixLength :: Maybe PrefixLength
747 , queryStringPhraseSlop :: Maybe PhraseSlop
748 , queryStringBoost :: Maybe Boost
749 , queryStringAnalyzeWildcard :: Maybe AnalyzeWildcard
750 , queryStringGeneratePhraseQueries :: Maybe GeneratePhraseQueries
751 , queryStringMinimumShouldMatch :: Maybe MinimumMatch
752 , queryStringLenient :: Maybe Lenient
753 , queryStringLocale :: Maybe Locale
754 } deriving (Eq, Show)
756mkQueryStringQuery :: QueryString -> QueryStringQuery
757mkQueryStringQuery qs =
758 QueryStringQuery qs Nothing Nothing
759 Nothing Nothing Nothing Nothing
760 Nothing Nothing Nothing Nothing
761 Nothing Nothing Nothing Nothing
762 Nothing Nothing
764data FieldOrFields = FofField FieldName
765 | FofFields [FieldName] deriving (Eq, Show)
767data PrefixQuery =
768 PrefixQuery
769 { prefixQueryField :: FieldName
770 , prefixQueryPrefixValue :: Text
771 , prefixQueryBoost :: Maybe Boost } deriving (Eq, Show)
773data NestedQuery =
774 NestedQuery
775 { nestedQueryPath :: QueryPath
776 , nestedQueryScoreType :: ScoreType
777 , nestedQuery :: Query } deriving (Eq, Show)
779data MoreLikeThisFieldQuery =
780 MoreLikeThisFieldQuery
781 { moreLikeThisFieldText :: Text
782 , moreLikeThisFieldFields :: FieldName
783 -- default 0.3 (30%)
784 , moreLikeThisFieldPercentMatch :: Maybe PercentMatch
785 , moreLikeThisFieldMinimumTermFreq :: Maybe MinimumTermFrequency
786 , moreLikeThisFieldMaxQueryTerms :: Maybe MaxQueryTerms
787 , moreLikeThisFieldStopWords :: Maybe [StopWord]
788 , moreLikeThisFieldMinDocFrequency :: Maybe MinDocFrequency
789 , moreLikeThisFieldMaxDocFrequency :: Maybe MaxDocFrequency
790 , moreLikeThisFieldMinWordLength :: Maybe MinWordLength
791 , moreLikeThisFieldMaxWordLength :: Maybe MaxWordLength
792 , moreLikeThisFieldBoostTerms :: Maybe BoostTerms
793 , moreLikeThisFieldBoost :: Maybe Boost
794 , moreLikeThisFieldAnalyzer :: Maybe Analyzer
795 } deriving (Eq, Show)
797data MoreLikeThisQuery =
798 MoreLikeThisQuery
799 { moreLikeThisText :: Text
800 , moreLikeThisFields :: Maybe [FieldName]
801 -- default 0.3 (30%)
802 , moreLikeThisPercentMatch :: Maybe PercentMatch
803 , moreLikeThisMinimumTermFreq :: Maybe MinimumTermFrequency
804 , moreLikeThisMaxQueryTerms :: Maybe MaxQueryTerms
805 , moreLikeThisStopWords :: Maybe [StopWord]
806 , moreLikeThisMinDocFrequency :: Maybe MinDocFrequency
807 , moreLikeThisMaxDocFrequency :: Maybe MaxDocFrequency
808 , moreLikeThisMinWordLength :: Maybe MinWordLength
809 , moreLikeThisMaxWordLength :: Maybe MaxWordLength
810 , moreLikeThisBoostTerms :: Maybe BoostTerms
811 , moreLikeThisBoost :: Maybe Boost
812 , moreLikeThisAnalyzer :: Maybe Analyzer
813 } deriving (Eq, Show)
815data IndicesQuery =
816 IndicesQuery
817 { indicesQueryIndices :: [IndexName]
818 , indicesQuery :: Query
819 -- default "all"
820 , indicesQueryNoMatch :: Maybe Query } deriving (Eq, Show)
822data HasParentQuery =
823 HasParentQuery
824 { hasParentQueryType :: TypeName
825 , hasParentQuery :: Query
826 , hasParentQueryScoreType :: Maybe ScoreType } deriving (Eq, Show)
828data HasChildQuery =
829 HasChildQuery
830 { hasChildQueryType :: TypeName
831 , hasChildQuery :: Query
832 , hasChildQueryScoreType :: Maybe ScoreType } deriving (Eq, Show)
834data ScoreType =
835 ScoreTypeMax
836 | ScoreTypeSum
837 | ScoreTypeAvg
838 | ScoreTypeNone deriving (Eq, Show)
840data FuzzyQuery =
841 FuzzyQuery { fuzzyQueryField :: FieldName
842 , fuzzyQueryValue :: Text
843 , fuzzyQueryPrefixLength :: PrefixLength
844 , fuzzyQueryMaxExpansions :: MaxExpansions
845 , fuzzyQueryFuzziness :: Fuzziness
846 , fuzzyQueryBoost :: Maybe Boost
847 } deriving (Eq, Show)
849data FuzzyLikeFieldQuery =
850 FuzzyLikeFieldQuery
851 { fuzzyLikeField :: FieldName
852 -- anaphora is good for the soul.
853 , fuzzyLikeFieldText :: Text
854 , fuzzyLikeFieldMaxQueryTerms :: MaxQueryTerms
855 , fuzzyLikeFieldIgnoreTermFrequency :: IgnoreTermFrequency
856 , fuzzyLikeFieldFuzziness :: Fuzziness
857 , fuzzyLikeFieldPrefixLength :: PrefixLength
858 , fuzzyLikeFieldBoost :: Boost
859 , fuzzyLikeFieldAnalyzer :: Maybe Analyzer
860 } deriving (Eq, Show)
862data FuzzyLikeThisQuery =
863 FuzzyLikeThisQuery
864 { fuzzyLikeFields :: [FieldName]
865 , fuzzyLikeText :: Text
866 , fuzzyLikeMaxQueryTerms :: MaxQueryTerms
867 , fuzzyLikeIgnoreTermFrequency :: IgnoreTermFrequency
868 , fuzzyLikeFuzziness :: Fuzziness
869 , fuzzyLikePrefixLength :: PrefixLength
870 , fuzzyLikeBoost :: Boost
871 , fuzzyLikeAnalyzer :: Maybe Analyzer
872 } deriving (Eq, Show)
874data FilteredQuery =
875 FilteredQuery
876 { filteredQuery :: Query
877 , filteredFilter :: Filter } deriving (Eq, Show)
879data DisMaxQuery =
880 DisMaxQuery { disMaxQueries :: [Query]
881 -- default 0.0
882 , disMaxTiebreaker :: Tiebreaker
883 , disMaxBoost :: Maybe Boost
884 } deriving (Eq, Show)
886data MatchQuery =
887 MatchQuery { matchQueryField :: FieldName
888 , matchQueryQueryString :: QueryString
889 , matchQueryOperator :: BooleanOperator
890 , matchQueryZeroTerms :: ZeroTermsQuery
891 , matchQueryCutoffFrequency :: Maybe CutoffFrequency
892 , matchQueryMatchType :: Maybe MatchQueryType
893 , matchQueryAnalyzer :: Maybe Analyzer
894 , matchQueryMaxExpansions :: Maybe MaxExpansions
895 , matchQueryLenient :: Maybe Lenient } deriving (Eq, Show)
897{-| 'mkMatchQuery' is a convenience function that defaults the less common parameters,
898 enabling you to provide only the 'FieldName' and 'QueryString' to make a 'MatchQuery'
899-}
900mkMatchQuery :: FieldName -> QueryString -> MatchQuery
901mkMatchQuery field query = MatchQuery field query Or ZeroTermsNone Nothing Nothing Nothing Nothing Nothing
903data MatchQueryType =
904 MatchPhrase
905 | MatchPhrasePrefix deriving (Eq, Show)
907data MultiMatchQuery =
908 MultiMatchQuery { multiMatchQueryFields :: [FieldName]
909 , multiMatchQueryString :: QueryString
910 , multiMatchQueryOperator :: BooleanOperator
911 , multiMatchQueryZeroTerms :: ZeroTermsQuery
912 , multiMatchQueryTiebreaker :: Maybe Tiebreaker
913 , multiMatchQueryType :: Maybe MultiMatchQueryType
914 , multiMatchQueryCutoffFrequency :: Maybe CutoffFrequency
915 , multiMatchQueryAnalyzer :: Maybe Analyzer
916 , multiMatchQueryMaxExpansions :: Maybe MaxExpansions
917 , multiMatchQueryLenient :: Maybe Lenient } deriving (Eq, Show)
919{-| 'mkMultiMatchQuery' is a convenience function that defaults the less common parameters,
920 enabling you to provide only the list of 'FieldName's and 'QueryString' to
921 make a 'MultiMatchQuery'.
922-}
924mkMultiMatchQuery :: [FieldName] -> QueryString -> MultiMatchQuery
925mkMultiMatchQuery matchFields query =
926 MultiMatchQuery matchFields query
927 Or ZeroTermsNone Nothing Nothing Nothing Nothing Nothing Nothing
929data MultiMatchQueryType =
930 MultiMatchBestFields
931 | MultiMatchMostFields
932 | MultiMatchCrossFields
933 | MultiMatchPhrase
934 | MultiMatchPhrasePrefix deriving (Eq, Show)
936data BoolQuery =
937 BoolQuery { boolQueryMustMatch :: [Query]
938 , boolQueryMustNotMatch :: [Query]
939 , boolQueryShouldMatch :: [Query]
940 , boolQueryMinimumShouldMatch :: Maybe MinimumMatch
941 , boolQueryBoost :: Maybe Boost
942 , boolQueryDisableCoord :: Maybe DisableCoord
943 } deriving (Eq, Show)
945mkBoolQuery :: [Query] -> [Query] -> [Query] -> BoolQuery
946mkBoolQuery must mustNot should =
947 BoolQuery must mustNot should Nothing Nothing Nothing
949data BoostingQuery =
950 BoostingQuery { positiveQuery :: Query
951 , negativeQuery :: Query
952 , negativeBoost :: Boost } deriving (Eq, Show)
954data CommonTermsQuery =
955 CommonTermsQuery { commonField :: FieldName
956 , commonQuery :: QueryString
957 , commonCutoffFrequency :: CutoffFrequency
958 , commonLowFreqOperator :: BooleanOperator
959 , commonHighFreqOperator :: BooleanOperator
960 , commonMinimumShouldMatch :: Maybe CommonMinimumMatch
961 , commonBoost :: Maybe Boost
962 , commonAnalyzer :: Maybe Analyzer
963 , commonDisableCoord :: Maybe DisableCoord
964 } deriving (Eq, Show)
966data CommonMinimumMatch =
967 CommonMinimumMatchHighLow MinimumMatchHighLow
968 | CommonMinimumMatch MinimumMatch
969 deriving (Eq, Show)
971data MinimumMatchHighLow =
972 MinimumMatchHighLow { lowFreq :: MinimumMatch
973 , highFreq :: MinimumMatch } deriving (Eq, Show)
975data Filter = AndFilter [Filter] Cache
976 | OrFilter [Filter] Cache
977 | NotFilter Filter Cache
978 | IdentityFilter
979 | BoolFilter BoolMatch
980 | ExistsFilter FieldName -- always cached
981 | GeoBoundingBoxFilter GeoBoundingBoxConstraint
982 | GeoDistanceFilter GeoPoint Distance DistanceType OptimizeBbox Cache
983 | GeoDistanceRangeFilter GeoPoint DistanceRange
984 | GeoPolygonFilter FieldName [LatLon]
985 | IdsFilter MappingName [DocId]
986 | LimitFilter Int
987 | MissingFilter FieldName Existence NullValue
988 | PrefixFilter FieldName PrefixValue Cache
989 | RangeFilter FieldName RangeValue RangeExecution Cache
990 | RegexpFilter FieldName Regexp RegexpFlags CacheName Cache CacheKey
991 | TermFilter Term Cache
992 deriving (Eq, Show)
994data ZeroTermsQuery = ZeroTermsNone
995 | ZeroTermsAll deriving (Eq, Show)
997data RangeExecution = RangeExecutionIndex
998 | RangeExecutionFielddata deriving (Eq, Show)
1000newtype Regexp = Regexp Text deriving (Eq, Show)
1002data RegexpFlags = AllRegexpFlags
1003 | NoRegexpFlags
1004 | SomeRegexpFlags (NonEmpty RegexpFlag) deriving (Eq, Show)
1006data RegexpFlag = AnyString
1007 | Automaton
1008 | Complement
1009 | Empty
1010 | Intersection
1011 | Interval deriving (Eq, Show)
1013newtype LessThan = LessThan Double deriving (Eq, Show)
1014newtype LessThanEq = LessThanEq Double deriving (Eq, Show)
1015newtype GreaterThan = GreaterThan Double deriving (Eq, Show)
1016newtype GreaterThanEq = GreaterThanEq Double deriving (Eq, Show)
1018newtype LessThanD = LessThanD UTCTime deriving (Eq, Show)
1019newtype LessThanEqD = LessThanEqD UTCTime deriving (Eq, Show)
1020newtype GreaterThanD = GreaterThanD UTCTime deriving (Eq, Show)
1021newtype GreaterThanEqD = GreaterThanEqD UTCTime deriving (Eq, Show)
1023data RangeValue = RangeDateLte LessThanEqD
1024 | RangeDateLt LessThanD
1025 | RangeDateGte GreaterThanEqD
1026 | RangeDateGt GreaterThanD
1027 | RangeDateGtLt GreaterThanD LessThanD
1028 | RangeDateGteLte GreaterThanEqD LessThanEqD
1029 | RangeDateGteLt GreaterThanEqD LessThanD
1030 | RangeDateGtLte GreaterThanD LessThanEqD
1031 | RangeDoubleLte LessThanEq
1032 | RangeDoubleLt LessThan
1033 | RangeDoubleGte GreaterThanEq
1034 | RangeDoubleGt GreaterThan
1035 | RangeDoubleGtLt GreaterThan LessThan
1036 | RangeDoubleGteLte GreaterThanEq LessThanEq
1037 | RangeDoubleGteLt GreaterThanEq LessThan
1038 | RangeDoubleGtLte GreaterThan LessThanEq
1039 deriving (Eq, Show)
1041rangeValueToPair :: RangeValue -> [Pair]
1042rangeValueToPair rv = case rv of
1043 RangeDateLte (LessThanEqD t) -> ["lte" .= t]
1044 RangeDateGte (GreaterThanEqD t) -> ["gte" .= t]
1045 RangeDateLt (LessThanD t) -> ["lt" .= t]
1046 RangeDateGt (GreaterThanD t) -> ["gt" .= t]
1047 RangeDateGteLte (GreaterThanEqD l) (LessThanEqD g) -> ["gte" .= l, "lte" .= g]
1048 RangeDateGtLte (GreaterThanD l) (LessThanEqD g) -> ["gt" .= l, "lte" .= g]
1049 RangeDateGteLt (GreaterThanEqD l) (LessThanD g) -> ["gte" .= l, "lt" .= g]
1050 RangeDateGtLt (GreaterThanD l) (LessThanD g) -> ["gt" .= l, "lt" .= g]
1051 RangeDoubleLte (LessThanEq t) -> ["lte" .= t]
1052 RangeDoubleGte (GreaterThanEq t) -> ["gte" .= t]
1053 RangeDoubleLt (LessThan t) -> ["lt" .= t]
1054 RangeDoubleGt (GreaterThan t) -> ["gt" .= t]
1055 RangeDoubleGteLte (GreaterThanEq l) (LessThanEq g) -> ["gte" .= l, "lte" .= g]
1056 RangeDoubleGtLte (GreaterThan l) (LessThanEq g) -> ["gt" .= l, "lte" .= g]
1057 RangeDoubleGteLt (GreaterThanEq l) (LessThan g) -> ["gte" .= l, "lt" .= g]
1058 RangeDoubleGtLt (GreaterThan l) (LessThan g) -> ["gt" .= l, "lt" .= g]
1060data Term = Term { termField :: Text
1061 , termValue :: Text } deriving (Eq, Show)
1063data BoolMatch = MustMatch Term Cache
1064 | MustNotMatch Term Cache
1065 | ShouldMatch [Term] Cache deriving (Eq, Show)
1067-- "memory" or "indexed"
1068data GeoFilterType = GeoFilterMemory
1069 | GeoFilterIndexed deriving (Eq, Show)
1071data LatLon = LatLon { lat :: Double
1072 , lon :: Double } deriving (Eq, Show)
1074data GeoBoundingBox =
1075 GeoBoundingBox { topLeft :: LatLon
1076 , bottomRight :: LatLon } deriving (Eq, Show)
1078data GeoBoundingBoxConstraint =
1079 GeoBoundingBoxConstraint { geoBBField :: FieldName
1080 , constraintBox :: GeoBoundingBox
1081 , bbConstraintcache :: Cache
1082 , geoType :: GeoFilterType
1083 } deriving (Eq, Show)
1085data GeoPoint =
1086 GeoPoint { geoField :: FieldName
1087 , latLon :: LatLon} deriving (Eq, Show)
1089data DistanceUnit = Miles
1090 | Yards
1091 | Feet
1092 | Inches
1093 | Kilometers
1094 | Meters
1095 | Centimeters
1096 | Millimeters
1097 | NauticalMiles deriving (Eq, Show)
1099data DistanceType = Arc
1100 | SloppyArc -- doesn't exist <1.0
1101 | Plane deriving (Eq, Show)
1103data OptimizeBbox = OptimizeGeoFilterType GeoFilterType
1104 | NoOptimizeBbox deriving (Eq, Show)
1106data Distance =
1107 Distance { coefficient :: Double
1108 , unit :: DistanceUnit } deriving (Eq, Show)
1110data DistanceRange =
1111 DistanceRange { distanceFrom :: Distance
1112 , distanceTo :: Distance } deriving (Eq, Show)
1114data SearchResult a =
1115 SearchResult { took :: Int
1116 , timedOut :: Bool
1117 , shards :: ShardResult
1118 , searchHits :: SearchHits a
1119 , aggregations :: Maybe AggregationResults } deriving (Eq, Show)
1121type Score = Double
1123data SearchHits a =
1124 SearchHits { hitsTotal :: Int
1125 , maxScore :: Score
1126 , hits :: [Hit a] } deriving (Eq, Show)
1128data Hit a =
1129 Hit { hitIndex :: IndexName
1130 , hitType :: MappingName
1131 , hitDocId :: DocId
1132 , hitScore :: Score
1133 , hitSource :: a
1134 , hitHighlight :: Maybe HitHighlight } deriving (Eq, Show)
1136data ShardResult =
1137 ShardResult { shardTotal :: Int
1138 , shardsSuccessful :: Int
1139 , shardsFailed :: Int } deriving (Eq, Show, Generic)
1141type HitHighlight = M.Map Text [Text]
1143showText :: Show a => a -> Text
1144showText = T.pack . show
1146type Aggregations = M.Map Text Aggregation
1148emptyAggregations :: Aggregations
1149emptyAggregations = M.empty
1151mkAggregations :: Text -> Aggregation -> Aggregations
1152mkAggregations name aggregation = M.insert name aggregation emptyAggregations
1154data TermOrder = TermOrder{ termSortField :: Text
1155 , termSortOrder :: SortOrder } deriving (Eq, Show)
1157data TermInclusion = TermInclusion Text
1158 | TermPattern Text Text deriving (Eq, Show)
1160data CollectionMode = BreadthFirst
1161 | DepthFirst deriving (Eq, Show)
1163data ExecutionHint = Ordinals
1164 | GlobalOrdinals
1165 | GlobalOrdinalsHash
1166 | GlobalOrdinalsLowCardinality
1167 | Map deriving (Eq, Show)
1169data TimeInterval = Weeks
1170 | Days
1171 | Hours
1172 | Minutes
1173 | Seconds deriving (Eq)
1175data Interval = Year
1176 | Quarter
1177 | Month
1178 | Week
1179 | Day
1180 | Hour
1181 | Minute
1182 | Second
1183 | FractionalInterval Float TimeInterval deriving (Eq, Show)
1185data Aggregation = TermsAgg TermsAggregation
1186 | DateHistogramAgg DateHistogramAggregation deriving (Eq, Show)
1189data TermsAggregation = TermsAggregation { term :: Either Text Text
1190 , termInclude :: Maybe TermInclusion
1191 , termExclude :: Maybe TermInclusion
1192 , termOrder :: Maybe TermOrder
1193 , termMinDocCount :: Maybe Int
1194 , termSize :: Maybe Int
1195 , termShardSize :: Maybe Int
1196 , termCollectMode :: Maybe CollectionMode
1197 , termExecutionHint :: Maybe ExecutionHint
1198 , termAggs :: Maybe Aggregations
1199 } deriving (Eq, Show)
1201data DateHistogramAggregation = DateHistogramAggregation { dateField :: FieldName
1202 , dateInterval :: Interval
1203 , dateFormat :: Maybe Text
1204 , datePreZone :: Maybe Text
1205 , datePostZone :: Maybe Text
1206 , datePreOffset :: Maybe Text
1207 , datePostOffset :: Maybe Text
1208 , dateAggs :: Maybe Aggregations
1209 } deriving (Eq, Show)
1212mkTermsAggregation :: Text -> TermsAggregation
1213mkTermsAggregation t = TermsAggregation (Left t) Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing
1215mkTermsScriptAggregation :: Text -> TermsAggregation
1216mkTermsScriptAggregation t = TermsAggregation (Right t) Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing
1218mkDateHistogram :: FieldName -> Interval -> DateHistogramAggregation
1219mkDateHistogram t i = DateHistogramAggregation t i Nothing Nothing Nothing Nothing Nothing Nothing
1221instance ToJSON TermOrder where
1222 toJSON (TermOrder termSortField termSortOrder) = object [termSortField .= termSortOrder]
1224instance ToJSON TermInclusion where
1225 toJSON (TermInclusion x) = toJSON x
1226 toJSON (TermPattern pattern flags) = omitNulls [ "pattern" .= pattern,
1227 "flags" .= flags]
1229instance ToJSON CollectionMode where
1230 toJSON BreadthFirst = "breadth_first"
1231 toJSON DepthFirst = "depth_first"
1233instance ToJSON ExecutionHint where
1234 toJSON Ordinals = "ordinals"
1235 toJSON GlobalOrdinals = "global_ordinals"
1236 toJSON GlobalOrdinalsHash = "global_ordinals_hash"
1237 toJSON GlobalOrdinalsLowCardinality = "global_ordinals_low_cardinality"
1238 toJSON Map = "map"
1240instance ToJSON Interval where
1241 toJSON Year = "year"
1242 toJSON Quarter = "quarter"
1243 toJSON Month = "month"
1244 toJSON Week = "week"
1245 toJSON Day = "day"
1246 toJSON Hour = "hour"
1247 toJSON Minute = "minute"
1248 toJSON Second = "second"
1249 toJSON (FractionalInterval fraction interval) = toJSON $ show fraction ++ show interval
1251instance Show TimeInterval where
1252 show Weeks = "w"
1253 show Days = "d"
1254 show Hours = "h"
1255 show Minutes = "m"
1256 show Seconds = "s"
1258instance ToJSON Aggregation where
1259 toJSON (TermsAgg (TermsAggregation term include exclude order minDocCount size shardSize collectMode executionHint termAggs)) =
1260 omitNulls ["terms" .= omitNulls [ toJSON' term,
1261 "include" .= include,
1262 "exclude" .= exclude,
1263 "order" .= order,
1264 "min_doc_count" .= minDocCount,
1265 "size" .= size,
1266 "shard_size" .= shardSize,
1267 "collect_mode" .= collectMode,
1268 "execution_hint" .= executionHint
1269 ],
1270 "aggs" .= termAggs ]
1271 where
1272 toJSON' x = case x of { Left y -> "field" .= y; Right y -> "script" .= y }
1274 toJSON (DateHistogramAgg (DateHistogramAggregation field interval format preZone postZone preOffset postOffset dateHistoAggs)) =
1275 omitNulls ["date_histogram" .= omitNulls [ "field" .= field,
1276 "interval" .= interval,
1277 "format" .= format,
1278 "pre_zone" .= preZone,
1279 "post_zone" .= postZone,
1280 "pre_offset" .= preOffset,
1281 "post_offset" .= postOffset
1282 ],
1283 "aggs" .= dateHistoAggs ]
1285type AggregationResults = M.Map Text Value
1287class BucketAggregation a where
1288 key :: a -> Text
1289 docCount :: a -> Int
1290 aggs :: a -> Maybe AggregationResults
1293data Bucket a = Bucket { buckets :: [a]} deriving (Show)
1295data TermsResult = TermsResult { termKey :: Text
1296 , termsDocCount :: Int
1297 , termsAggs :: Maybe AggregationResults } deriving (Show)
1299data DateHistogramResult = DateHistogramResult { dateKey :: Int
1300 , dateKeyStr :: Maybe Text
1301 , dateDocCount :: Int
1302 , dateHistogramAggs :: Maybe AggregationResults } deriving (Show)
1304toTerms :: Text -> AggregationResults -> Maybe (Bucket TermsResult)
1305toTerms t a = M.lookup t a >>= deserialize
1306 where deserialize = parseMaybe parseJSON
1308toDateHistogram :: Text -> AggregationResults -> Maybe (Bucket DateHistogramResult)
1309toDateHistogram t a = M.lookup t a >>= deserialize
1310 where deserialize = parseMaybe parseJSON
1312instance BucketAggregation TermsResult where
1313 key = termKey
1314 docCount = termsDocCount
1315 aggs = termsAggs
1317instance BucketAggregation DateHistogramResult where
1318 key = showText . dateKey
1319 docCount = dateDocCount
1320 aggs = dateHistogramAggs
1322instance (FromJSON a, BucketAggregation a) => FromJSON (Bucket a) where
1323 parseJSON (Object v) = Bucket <$>
1324 v .: "buckets"
1325 parseJSON _ = mempty
1327instance FromJSON TermsResult where
1328 parseJSON (Object v) = TermsResult <$>
1329 v .: "key" <*>
1330 v .: "doc_count" <*>
1331 v .:? "aggregations"
1332 parseJSON _ = mempty
1334instance FromJSON DateHistogramResult where
1335 parseJSON (Object v) = DateHistogramResult <$>
1336 v .: "key" <*>
1337 v .:? "key_as_string" <*>
1338 v .: "doc_count" <*>
1339 v .:? "aggregations"
1340 parseJSON _ = mempty
1342instance Monoid Filter where
1343 mempty = IdentityFilter
1344 mappend a b = AndFilter [a, b] defaultCache
1346instance Seminearring Filter where
1347 a <||> b = OrFilter [a, b] defaultCache
1349instance ToJSON Filter where
1350 toJSON (AndFilter filters cache) =
1351 object ["and" .=
1352 object [ "filters" .= fmap toJSON filters
1353 , "_cache" .= cache]]
1355 toJSON (OrFilter filters cache) =
1356 object ["or" .= fmap toJSON filters
1357 , "_cache" .= cache]
1359 toJSON (NotFilter notFilter cache) =
1360 object ["not" .=
1361 object ["filter" .= notFilter
1362 , "_cache" .= cache]]
1364 toJSON (IdentityFilter) =
1365 object ["match_all" .= object []]
1367 toJSON (TermFilter (Term termFilterField termFilterValue) cache) =
1368 object ["term" .= object base]
1369 where base = [termFilterField .= termFilterValue,
1370 "_cache" .= cache]
1372 toJSON (ExistsFilter (FieldName fieldName)) =
1373 object ["exists" .= object
1374 ["field" .= fieldName]]
1376 toJSON (BoolFilter boolMatch) =
1377 object ["bool" .= boolMatch]
1379 toJSON (GeoBoundingBoxFilter bbConstraint) =
1380 object ["geo_bounding_box" .= bbConstraint]
1382 toJSON (GeoDistanceFilter (GeoPoint (FieldName distanceGeoField) geoDistLatLon)
1383 distance distanceType optimizeBbox cache) =
1384 object ["geo_distance" .=
1385 object ["distance" .= distance
1386 , "distance_type" .= distanceType
1387 , "optimize_bbox" .= optimizeBbox
1388 , distanceGeoField .= geoDistLatLon
1389 , "_cache" .= cache]]
1391 toJSON (GeoDistanceRangeFilter (GeoPoint (FieldName gddrField) drLatLon)
1392 (DistanceRange geoDistRangeDistFrom drDistanceTo)) =
1393 object ["geo_distance_range" .=
1394 object ["from" .= geoDistRangeDistFrom
1395 , "to" .= drDistanceTo
1396 , gddrField .= drLatLon]]
1398 toJSON (GeoPolygonFilter (FieldName geoPolygonFilterField) latLons) =
1399 object ["geo_polygon" .=
1400 object [geoPolygonFilterField .=
1401 object ["points" .= fmap toJSON latLons]]]
1403 toJSON (IdsFilter (MappingName mappingName) values) =
1404 object ["ids" .=
1405 object ["type" .= mappingName
1406 , "values" .= fmap unpackId values]]
1408 toJSON (LimitFilter limit) =
1409 object ["limit" .= object ["value" .= limit]]
1411 toJSON (MissingFilter (FieldName fieldName) (Existence existence) (NullValue nullValue)) =
1412 object ["missing" .=
1413 object ["field" .= fieldName
1414 , "existence" .= existence
1415 , "null_value" .= nullValue]]
1417 toJSON (PrefixFilter (FieldName fieldName) fieldValue cache) =
1418 object ["prefix" .=
1419 object [fieldName .= fieldValue
1420 , "_cache" .= cache]]
1422 toJSON (RangeFilter (FieldName fieldName) rangeValue rangeExecution cache) =
1423 object ["range" .=
1424 object [ fieldName .= object (rangeValueToPair rangeValue)
1425 , "execution" .= rangeExecution
1426 , "_cache" .= cache]]
1428 toJSON (RegexpFilter (FieldName fieldName)
1429 (Regexp regexText) flags (CacheName cacheName) cache (CacheKey cacheKey)) =
1430 object ["regexp" .=
1431 object [fieldName .=
1432 object ["value" .= regexText
1433 , "flags" .= flags]
1434 , "_name" .= cacheName
1435 , "_cache" .= cache
1436 , "_cache_key" .= cacheKey]]
1438instance ToJSON GeoPoint where
1439 toJSON (GeoPoint (FieldName geoPointField) geoPointLatLon) =
1440 object [ geoPointField .= geoPointLatLon ]
1443instance ToJSON Query where
1444 toJSON (TermQuery (Term termQueryField termQueryValue) boost) =
1445 object [ "term" .=
1446 object [termQueryField .= object merged]]
1447 where
1448 base = [ "value" .= termQueryValue ]
1449 boosted = maybe [] (return . ("boost" .=)) boost
1450 merged = mappend base boosted
1452 toJSON (TermsQuery terms) =
1453 object [ "terms" .= object conjoined ]
1454 where conjoined = [ getTermsField terms .=
1455 fmap (toJSON . getTermValue) (toList terms)]
1456 getTermsField ((Term f _ ) :| _) = f
1457 getTermValue (Term _ v) = v
1458 toJSON (IdsQuery idsQueryMappingName docIds) =
1459 object [ "ids" .= object conjoined ]
1460 where conjoined = [ "type" .= idsQueryMappingName
1461 , "values" .= fmap toJSON docIds ]
1463 toJSON (QueryQueryStringQuery qQueryStringQuery) =
1464 object [ "query_string" .= qQueryStringQuery ]
1466 toJSON (QueryMatchQuery matchQuery) =
1467 object [ "match" .= matchQuery ]
1469 toJSON (QueryMultiMatchQuery multiMatchQuery) =
1470 toJSON multiMatchQuery
1472 toJSON (QueryBoolQuery boolQuery) =
1473 object [ "bool" .= boolQuery ]
1475 toJSON (QueryBoostingQuery boostingQuery) =
1476 object [ "boosting" .= boostingQuery ]
1478 toJSON (QueryCommonTermsQuery commonTermsQuery) =
1479 object [ "common" .= commonTermsQuery ]
1481 toJSON (ConstantScoreFilter csFilter boost) =
1482 object [ "constant_score" .= csFilter
1483 , "boost" .= boost]
1485 toJSON (ConstantScoreQuery query boost) =
1486 object [ "constant_score" .= query
1487 , "boost" .= boost]
1489 toJSON (QueryDisMaxQuery disMaxQuery) =
1490 object [ "dis_max" .= disMaxQuery ]
1492 toJSON (QueryFilteredQuery qFilteredQuery) =
1493 object [ "filtered" .= qFilteredQuery ]
1495 toJSON (QueryFuzzyLikeThisQuery fuzzyQuery) =
1496 object [ "fuzzy_like_this" .= fuzzyQuery ]
1498 toJSON (QueryFuzzyLikeFieldQuery fuzzyFieldQuery) =
1499 object [ "fuzzy_like_this_field" .= fuzzyFieldQuery ]
1501 toJSON (QueryFuzzyQuery fuzzyQuery) =
1502 object [ "fuzzy" .= fuzzyQuery ]
1504 toJSON (QueryHasChildQuery childQuery) =
1505 object [ "has_child" .= childQuery ]
1507 toJSON (QueryHasParentQuery parentQuery) =
1508 object [ "has_parent" .= parentQuery ]
1510 toJSON (QueryIndicesQuery qIndicesQuery) =
1511 object [ "indices" .= qIndicesQuery ]
1513 toJSON (MatchAllQuery boost) =
1514 object [ "match_all" .= omitNulls [ "boost" .= boost ] ]
1516 toJSON (QueryMoreLikeThisQuery query) =
1517 object [ "more_like_this" .= query ]
1519 toJSON (QueryMoreLikeThisFieldQuery query) =
1520 object [ "more_like_this_field" .= query ]
1522 toJSON (QueryNestedQuery query) =
1523 object [ "nested" .= query ]
1525 toJSON (QueryPrefixQuery query) =
1526 object [ "prefix" .= query ]
1528 toJSON (QueryRangeQuery query) =
1529 object [ "range" .= query ]
1531 toJSON (QueryRegexpQuery query) =
1532 object [ "regexp" .= query ]
1534 toJSON (QuerySimpleQueryStringQuery query) =
1535 object [ "simple_query_string" .= query ]
1538omitNulls :: [(Text, Value)] -> Value
1539omitNulls = object . filter notNull where
1540 notNull (_, Null) = False
1541 notNull (_, Array a) = (not . V.null) a
1542 notNull _ = True
1545instance ToJSON SimpleQueryStringQuery where
1546 toJSON SimpleQueryStringQuery {..} =
1547 omitNulls (base ++ maybeAdd)
1548 where base = [ "query" .= simpleQueryStringQuery ]
1549 maybeAdd = [ "fields" .= simpleQueryStringField
1550 , "default_operator" .= simpleQueryStringOperator
1551 , "analyzer" .= simpleQueryStringAnalyzer
1552 , "flags" .= simpleQueryStringFlags
1553 , "lowercase_expanded_terms" .= simpleQueryStringLowercaseExpanded
1554 , "locale" .= simpleQueryStringLocale ]
1557instance ToJSON FieldOrFields where
1558 toJSON (FofField fieldName) =
1559 toJSON fieldName
1560 toJSON (FofFields fieldNames) =
1561 toJSON fieldNames
1563instance ToJSON SimpleQueryFlag where
1564 toJSON SimpleQueryAll = "ALL"
1565 toJSON SimpleQueryNone = "NONE"
1566 toJSON SimpleQueryAnd = "AND"
1567 toJSON SimpleQueryOr = "OR"
1568 toJSON SimpleQueryPrefix = "PREFIX"
1569 toJSON SimpleQueryPhrase = "PHRASE"
1570 toJSON SimpleQueryPrecedence = "PRECEDENCE"
1571 toJSON SimpleQueryEscape = "ESCAPE"
1572 toJSON SimpleQueryWhitespace = "WHITESPACE"
1573 toJSON SimpleQueryFuzzy = "FUZZY"
1574 toJSON SimpleQueryNear = "NEAR"
1575 toJSON SimpleQuerySlop = "SLOP"
1578instance ToJSON RegexpQuery where
1579 toJSON (RegexpQuery (FieldName rqQueryField)
1580 (Regexp regexpQueryQuery) rqQueryFlags
1581 rqQueryBoost) =
1582 object [ rqQueryField .= omitNulls base ]
1583 where base = [ "value" .= regexpQueryQuery
1584 , "flags" .= rqQueryFlags
1585 , "boost" .= rqQueryBoost ]
1588instance ToJSON QueryStringQuery where
1589 toJSON (QueryStringQuery qsQueryString
1590 qsDefaultField qsOperator
1591 qsAnalyzer qsAllowWildcard
1592 qsLowercaseExpanded qsEnablePositionIncrements
1593 qsFuzzyMaxExpansions qsFuzziness
1594 qsFuzzyPrefixLength qsPhraseSlop
1595 qsBoost qsAnalyzeWildcard
1596 qsGeneratePhraseQueries qsMinimumShouldMatch
1597 qsLenient qsLocale) =
1598 omitNulls base
1599 where
1600 base = [ "query" .= qsQueryString
1601 , "default_field" .= qsDefaultField
1602 , "default_operator" .= qsOperator
1603 , "analyzer" .= qsAnalyzer
1604 , "allow_leading_wildcard" .= qsAllowWildcard
1605 , "lowercase_expanded_terms" .= qsLowercaseExpanded
1606 , "enable_position_increments" .= qsEnablePositionIncrements
1607 , "fuzzy_max_expansions" .= qsFuzzyMaxExpansions
1608 , "fuzziness" .= qsFuzziness
1609 , "fuzzy_prefix_length" .= qsFuzzyPrefixLength
1610 , "phrase_slop" .= qsPhraseSlop
1611 , "boost" .= qsBoost
1612 , "analyze_wildcard" .= qsAnalyzeWildcard
1613 , "auto_generate_phrase_queries" .= qsGeneratePhraseQueries
1614 , "minimum_should_match" .= qsMinimumShouldMatch
1615 , "lenient" .= qsLenient
1616 , "locale" .= qsLocale ]
1619instance ToJSON RangeQuery where
1620 toJSON (RangeQuery (FieldName fieldName) range boost) =
1621 object [ fieldName .= conjoined ]
1622 where conjoined = [ "boost" .= boost ] ++ (rangeValueToPair range)
1625instance ToJSON PrefixQuery where
1626 toJSON (PrefixQuery (FieldName fieldName) queryValue boost) =
1627 object [ fieldName .= omitNulls base ]
1628 where base = [ "value" .= queryValue
1629 , "boost" .= boost ]
1632instance ToJSON NestedQuery where
1633 toJSON (NestedQuery nqPath nqScoreType nqQuery) =
1634 object [ "path" .= nqPath
1635 , "score_mode" .= nqScoreType
1636 , "query" .= nqQuery ]
1639instance ToJSON MoreLikeThisFieldQuery where
1640 toJSON (MoreLikeThisFieldQuery text (FieldName fieldName)
1641 percent mtf mqt stopwords mindf maxdf
1642 minwl maxwl boostTerms boost analyzer) =
1643 object [ fieldName .= omitNulls base ]
1644 where base = [ "like_text" .= text
1645 , "percent_terms_to_match" .= percent
1646 , "min_term_freq" .= mtf
1647 , "max_query_terms" .= mqt
1648 , "stop_words" .= stopwords
1649 , "min_doc_freq" .= mindf
1650 , "max_doc_freq" .= maxdf
1651 , "min_word_length" .= minwl
1652 , "max_word_length" .= maxwl
1653 , "boost_terms" .= boostTerms
1654 , "boost" .= boost
1655 , "analyzer" .= analyzer ]
1658instance ToJSON MoreLikeThisQuery where
1659 toJSON (MoreLikeThisQuery text fields percent
1660 mtf mqt stopwords mindf maxdf
1661 minwl maxwl boostTerms boost analyzer) =
1662 omitNulls base
1663 where base = [ "like_text" .= text
1664 , "fields" .= fields
1665 , "percent_terms_to_match" .= percent
1666 , "min_term_freq" .= mtf
1667 , "max_query_terms" .= mqt
1668 , "stop_words" .= stopwords
1669 , "min_doc_freq" .= mindf
1670 , "max_doc_freq" .= maxdf
1671 , "min_word_length" .= minwl
1672 , "max_word_length" .= maxwl
1673 , "boost_terms" .= boostTerms
1674 , "boost" .= boost
1675 , "analyzer" .= analyzer ]
1678instance ToJSON IndicesQuery where
1679 toJSON (IndicesQuery indices query noMatch) =
1680 omitNulls [ "indices" .= indices
1681 , "no_match_query" .= noMatch
1682 , "query" .= query ]
1685instance ToJSON HasParentQuery where
1686 toJSON (HasParentQuery queryType query scoreType) =
1687 omitNulls [ "parent_type" .= queryType
1688 , "score_type" .= scoreType
1689 , "query" .= query ]
1692instance ToJSON HasChildQuery where
1693 toJSON (HasChildQuery queryType query scoreType) =
1694 omitNulls [ "query" .= query
1695 , "score_type" .= scoreType
1696 , "type" .= queryType ]
1699instance ToJSON FuzzyQuery where
1700 toJSON (FuzzyQuery (FieldName fieldName) queryText
1701 prefixLength maxEx fuzziness boost) =
1702 object [ fieldName .= omitNulls base ]
1703 where base = [ "value" .= queryText
1704 , "fuzziness" .= fuzziness
1705 , "prefix_length" .= prefixLength
1706 , "boost" .= boost
1707 , "max_expansions" .= maxEx ]
1710instance ToJSON FuzzyLikeFieldQuery where
1711 toJSON (FuzzyLikeFieldQuery (FieldName fieldName)
1712 fieldText maxTerms ignoreFreq fuzziness prefixLength
1713 boost analyzer) =
1714 object [ fieldName .=
1715 omitNulls [ "like_text" .= fieldText
1716 , "max_query_terms" .= maxTerms
1717 , "ignore_tf" .= ignoreFreq
1718 , "fuzziness" .= fuzziness
1719 , "prefix_length" .= prefixLength
1720 , "analyzer" .= analyzer
1721 , "boost" .= boost ]]
1724instance ToJSON FuzzyLikeThisQuery where
1725 toJSON (FuzzyLikeThisQuery fields text maxTerms
1726 ignoreFreq fuzziness prefixLength boost analyzer) =
1727 omitNulls base
1728 where base = [ "fields" .= fields
1729 , "like_text" .= text
1730 , "max_query_terms" .= maxTerms
1731 , "ignore_tf" .= ignoreFreq
1732 , "fuzziness" .= fuzziness
1733 , "prefix_length" .= prefixLength
1734 , "analyzer" .= analyzer
1735 , "boost" .= boost ]
1738instance ToJSON FilteredQuery where
1739 toJSON (FilteredQuery query fFilter) =
1740 object [ "query" .= query
1741 , "filter" .= fFilter ]
1744instance ToJSON DisMaxQuery where
1745 toJSON (DisMaxQuery queries tiebreaker boost) =
1746 omitNulls base
1747 where base = [ "queries" .= queries
1748 , "boost" .= boost
1749 , "tie_breaker" .= tiebreaker ]
1752instance ToJSON CommonTermsQuery where
1753 toJSON (CommonTermsQuery (FieldName fieldName)
1754 (QueryString query) cf lfo hfo msm
1755 boost analyzer disableCoord) =
1756 object [fieldName .= omitNulls base ]
1757 where base = [ "query" .= query
1758 , "cutoff_frequency" .= cf
1759 , "low_freq_operator" .= lfo
1760 , "minimum_should_match" .= msm
1761 , "boost" .= boost
1762 , "analyzer" .= analyzer
1763 , "disable_coord" .= disableCoord
1764 , "high_freq_operator" .= hfo ]
1767instance ToJSON CommonMinimumMatch where
1768 toJSON (CommonMinimumMatch mm) = toJSON mm
1769 toJSON (CommonMinimumMatchHighLow (MinimumMatchHighLow lowF highF)) =
1770 object [ "low_freq" .= lowF
1771 , "high_freq" .= highF ]
1773instance ToJSON BoostingQuery where
1774 toJSON (BoostingQuery bqPositiveQuery bqNegativeQuery bqNegativeBoost) =
1775 object [ "positive" .= bqPositiveQuery
1776 , "negative" .= bqNegativeQuery
1777 , "negative_boost" .= bqNegativeBoost ]
1780instance ToJSON BoolQuery where
1781 toJSON (BoolQuery mustM notM shouldM bqMin boost disableCoord) =
1782 omitNulls base
1783 where base = [ "must" .= mustM
1784 , "must_not" .= notM
1785 , "should" .= shouldM
1786 , "minimum_should_match" .= bqMin
1787 , "boost" .= boost
1788 , "disable_coord" .= disableCoord ]
1791instance ToJSON MatchQuery where
1792 toJSON (MatchQuery (FieldName fieldName)
1793 (QueryString mqQueryString) booleanOperator
1794 zeroTermsQuery cutoffFrequency matchQueryType
1795 analyzer maxExpansions lenient) =
1796 object [ fieldName .= omitNulls base ]
1797 where base = [ "query" .= mqQueryString
1798 , "operator" .= booleanOperator
1799 , "zero_terms_query" .= zeroTermsQuery
1800 , "cutoff_frequency" .= cutoffFrequency
1801 , "type" .= matchQueryType
1802 , "analyzer" .= analyzer
1803 , "max_expansions" .= maxExpansions
1804 , "lenient" .= lenient ]
1807instance ToJSON MultiMatchQuery where
1808 toJSON (MultiMatchQuery fields (QueryString query) boolOp
1809 ztQ tb mmqt cf analyzer maxEx lenient) =
1810 object ["multi_match" .= omitNulls base]
1811 where base = [ "fields" .= fmap toJSON fields
1812 , "query" .= query
1813 , "operator" .= boolOp
1814 , "zero_terms_query" .= ztQ
1815 , "tiebreaker" .= tb
1816 , "type" .= mmqt
1817 , "cutoff_frequency" .= cf
1818 , "analyzer" .= analyzer
1819 , "max_expansions" .= maxEx
1820 , "lenient" .= lenient ]
1823instance ToJSON MultiMatchQueryType where
1824 toJSON MultiMatchBestFields = "best_fields"
1825 toJSON MultiMatchMostFields = "most_fields"
1826 toJSON MultiMatchCrossFields = "cross_fields"
1827 toJSON MultiMatchPhrase = "phrase"
1828 toJSON MultiMatchPhrasePrefix = "phrase_prefix"
1830instance ToJSON BooleanOperator where
1831 toJSON And = String "and"
1832 toJSON Or = String "or"
1834instance ToJSON ZeroTermsQuery where
1835 toJSON ZeroTermsNone = String "none"
1836 toJSON ZeroTermsAll = String "all"
1838instance ToJSON MatchQueryType where
1839 toJSON MatchPhrase = "phrase"
1840 toJSON MatchPhrasePrefix = "phrase_prefix"
1842instance ToJSON FieldName where
1843 toJSON (FieldName fieldName) = String fieldName
1845instance ToJSON ReplicaCount
1846instance ToJSON ShardCount
1847instance ToJSON CutoffFrequency
1848instance ToJSON Analyzer
1849instance ToJSON MaxExpansions
1850instance ToJSON Lenient
1851instance ToJSON Boost
1852instance ToJSON Version
1853instance ToJSON Tiebreaker
1854instance ToJSON MinimumMatch
1855instance ToJSON DisableCoord
1856instance ToJSON PrefixLength
1857instance ToJSON Fuzziness
1858instance ToJSON IgnoreTermFrequency
1859instance ToJSON MaxQueryTerms
1860instance ToJSON TypeName
1861instance ToJSON IndexName
1862instance ToJSON BoostTerms
1863instance ToJSON MaxWordLength
1864instance ToJSON MinWordLength
1865instance ToJSON MaxDocFrequency
1866instance ToJSON MinDocFrequency
1867instance ToJSON PhraseSlop
1868instance ToJSON StopWord
1869instance ToJSON QueryPath
1870instance ToJSON MinimumTermFrequency
1871instance ToJSON PercentMatch
1872instance ToJSON MappingName
1873instance ToJSON DocId
1874instance ToJSON QueryString
1875instance ToJSON AllowLeadingWildcard
1876instance ToJSON LowercaseExpanded
1877instance ToJSON AnalyzeWildcard
1878instance ToJSON GeneratePhraseQueries
1879instance ToJSON Locale
1880instance ToJSON EnablePositionIncrements
1881instance FromJSON Version
1882instance FromJSON IndexName
1883instance FromJSON MappingName
1884instance FromJSON DocId
1887instance FromJSON Status where
1888 parseJSON (Object v) = Status <$>
1889 v .:? "ok" <*>
1890 v .: "status" <*>
1891 v .: "name" <*>
1892 v .: "version" <*>
1893 v .: "tagline"
1894 parseJSON _ = empty
1897instance ToJSON IndexSettings where
1898 toJSON (IndexSettings s r) = object ["settings" .= object ["shards" .= s, "replicas" .= r]]
1901instance (FromJSON a) => FromJSON (EsResult a) where
1902 parseJSON (Object v) = EsResult <$>
1903 v .: "_index" <*>
1904 v .: "_type" <*>
1905 v .: "_id" <*>
1906 v .: "_version" <*>
1907 v .:? "found" <*>
1908 v .: "_source"
1909 parseJSON _ = empty
1912instance ToJSON Search where
1913 toJSON (Search query sFilter sort searchAggs highlight sTrackSortScores sFrom sSize) =
1914 omitNulls [ "query" .= query
1915 , "filter" .= sFilter
1916 , "sort" .= sort
1917 , "aggregations" .= searchAggs
1918 , "highlight" .= highlight
1919 , "from" .= sFrom
1920 , "size" .= sSize
1921 , "track_scores" .= sTrackSortScores]
1924instance ToJSON FieldHighlight where
1925 toJSON (FieldHighlight (FieldName fName) (Just fSettings)) =
1926 object [ fName .= fSettings ]
1927 toJSON (FieldHighlight (FieldName fName) Nothing) =
1928 object [ fName .= emptyObject ]
1930instance ToJSON Highlights where
1931 toJSON (Highlights global fields) =
1932 omitNulls (("fields" .= fields)
1933 : highlightSettingsPairs global)
1935instance ToJSON HighlightSettings where
1936 toJSON hs = omitNulls (highlightSettingsPairs (Just hs))
1938highlightSettingsPairs :: Maybe HighlightSettings -> [Pair]
1939highlightSettingsPairs Nothing = []
1940highlightSettingsPairs (Just (Plain plh)) = plainHighPairs (Just plh)
1941highlightSettingsPairs (Just (Postings ph)) = postHighPairs (Just ph)
1942highlightSettingsPairs (Just (FastVector fvh)) = fastVectorHighPairs (Just fvh)
1945plainHighPairs :: Maybe PlainHighlight -> [Pair]
1946plainHighPairs Nothing = []
1947plainHighPairs (Just (PlainHighlight plCom plNonPost)) =
1948 [ "type" .= String "plain"]
1949 ++ commonHighlightPairs plCom
1950 ++ nonPostingsToPairs plNonPost
1952postHighPairs :: Maybe PostingsHighlight -> [Pair]
1953postHighPairs Nothing = []
1954postHighPairs (Just (PostingsHighlight pCom)) =
1955 ("type" .= String "postings")
1956 : commonHighlightPairs pCom
1958fastVectorHighPairs :: Maybe FastVectorHighlight -> [Pair]
1959fastVectorHighPairs Nothing = []
1960fastVectorHighPairs (Just
1961 (FastVectorHighlight fvCom fvNonPostSettings fvBoundChars
1962 fvBoundMaxScan fvFragOff fvMatchedFields
1963 fvPhraseLim)) =
1964 [ "type" .= String "fvh"
1965 , "boundary_chars" .= fvBoundChars
1966 , "boundary_max_scan" .= fvBoundMaxScan
1967 , "fragment_offset" .= fvFragOff
1968 , "matched_fields" .= fvMatchedFields
1969 , "phraseLimit" .= fvPhraseLim]
1970 ++ commonHighlightPairs fvCom
1971 ++ nonPostingsToPairs fvNonPostSettings
1973commonHighlightPairs :: Maybe CommonHighlight -> [Pair]
1974commonHighlightPairs Nothing = []
1975commonHighlightPairs (Just (CommonHighlight chScore chForceSource chTag chEncoder
1976 chNoMatchSize chHighlightQuery
1977 chRequireFieldMatch)) =
1978 [ "order" .= chScore
1979 , "force_source" .= chForceSource
1980 , "encoder" .= chEncoder
1981 , "no_match_size" .= chNoMatchSize
1982 , "highlight_query" .= chHighlightQuery
1983 , "require_fieldMatch" .= chRequireFieldMatch]
1984 ++ highlightTagToPairs chTag
1987nonPostingsToPairs :: Maybe NonPostings -> [Pair]
1988nonPostingsToPairs Nothing = []
1989nonPostingsToPairs (Just (NonPostings npFragSize npNumOfFrags)) =
1990 [ "fragment_size" .= npFragSize
1991 , "number_of_fragments" .= npNumOfFrags]
1995instance ToJSON HighlightEncoder where
1996 toJSON DefaultEncoder = String "default"
1997 toJSON HTMLEncoder = String "html"
1999highlightTagToPairs :: Maybe HighlightTag -> [Pair]
2000highlightTagToPairs (Just (TagSchema _)) = [ "scheme" .= String "default"]
2001highlightTagToPairs (Just (CustomTags (pre, post))) = [ "pre_tags" .= pre
2002 , "post_tags" .= post]
2003highlightTagToPairs Nothing = []
2005instance ToJSON SortSpec where
2006 toJSON (DefaultSortSpec
2007 (DefaultSort (FieldName dsSortFieldName) dsSortOrder dsIgnoreUnmapped
2008 dsSortMode dsMissingSort dsNestedFilter)) =
2009 object [dsSortFieldName .= omitNulls base] where
2010 base = [ "order" .= dsSortOrder
2011 , "ignore_unmapped" .= dsIgnoreUnmapped
2012 , "mode" .= dsSortMode
2013 , "missing" .= dsMissingSort
2014 , "nested_filter" .= dsNestedFilter ]
2016 toJSON (GeoDistanceSortSpec gdsSortOrder (GeoPoint (FieldName field) gdsLatLon) units) =
2017 object [ "unit" .= units
2018 , field .= gdsLatLon
2019 , "order" .= gdsSortOrder ]
2022instance ToJSON SortOrder where
2023 toJSON Ascending = String "asc"
2024 toJSON Descending = String "desc"
2027instance ToJSON SortMode where
2028 toJSON SortMin = String "min"
2029 toJSON SortMax = String "max"
2030 toJSON SortSum = String "sum"
2031 toJSON SortAvg = String "avg"
2034instance ToJSON Missing where
2035 toJSON LastMissing = String "_last"
2036 toJSON FirstMissing = String "_first"
2037 toJSON (CustomMissing txt) = String txt
2040instance ToJSON ScoreType where
2041 toJSON ScoreTypeMax = "max"
2042 toJSON ScoreTypeAvg = "avg"
2043 toJSON ScoreTypeSum = "sum"
2044 toJSON ScoreTypeNone = "none"
2047instance ToJSON Distance where
2048 toJSON (Distance dCoefficient dUnit) =
2049 String boltedTogether where
2050 coefText = showText dCoefficient
2051 (String unitText) = toJSON dUnit
2052 boltedTogether = mappend coefText unitText
2055instance ToJSON DistanceUnit where
2056 toJSON Miles = String "mi"
2057 toJSON Yards = String "yd"
2058 toJSON Feet = String "ft"
2059 toJSON Inches = String "in"
2060 toJSON Kilometers = String "km"
2061 toJSON Meters = String "m"
2062 toJSON Centimeters = String "cm"
2063 toJSON Millimeters = String "mm"
2064 toJSON NauticalMiles = String "nmi"
2067instance ToJSON DistanceType where
2068 toJSON Arc = String "arc"
2069 toJSON SloppyArc = String "sloppy_arc"
2070 toJSON Plane = String "plane"
2073instance ToJSON OptimizeBbox where
2074 toJSON NoOptimizeBbox = String "none"
2075 toJSON (OptimizeGeoFilterType gft) = toJSON gft
2078instance ToJSON GeoBoundingBoxConstraint where
2079 toJSON (GeoBoundingBoxConstraint
2080 (FieldName gbbcGeoBBField) gbbcConstraintBox cache type') =
2081 object [gbbcGeoBBField .= gbbcConstraintBox
2082 , "_cache" .= cache
2083 , "type" .= type']
2086instance ToJSON GeoFilterType where
2087 toJSON GeoFilterMemory = String "memory"
2088 toJSON GeoFilterIndexed = String "indexed"
2091instance ToJSON GeoBoundingBox where
2092 toJSON (GeoBoundingBox gbbTopLeft gbbBottomRight) =
2093 object ["top_left" .= gbbTopLeft
2094 , "bottom_right" .= gbbBottomRight]
2097instance ToJSON LatLon where
2098 toJSON (LatLon lLat lLon) =
2099 object ["lat" .= lLat
2100 , "lon" .= lLon]
2103-- index for smaller ranges, fielddata for longer ranges
2104instance ToJSON RangeExecution where
2105 toJSON RangeExecutionIndex = "index"
2106 toJSON RangeExecutionFielddata = "fielddata"
2109instance ToJSON RegexpFlags where
2110 toJSON AllRegexpFlags = String "ALL"
2111 toJSON NoRegexpFlags = String "NONE"
2112 toJSON (SomeRegexpFlags (h :| fs)) = String $ T.intercalate "|" flagStrs
2113 where flagStrs = map flagStr . nub $ h:fs
2114 flagStr AnyString = "ANYSTRING"
2115 flagStr Automaton = "AUTOMATON"
2116 flagStr Complement = "COMPLEMENT"
2117 flagStr Empty = "EMPTY"
2118 flagStr Intersection = "INTERSECTION"
2119 flagStr Interval = "INTERVAL"
2121instance ToJSON Term where
2122 toJSON (Term field value) = object ["term" .= object
2123 [field .= value]]
2126instance ToJSON BoolMatch where
2127 toJSON (MustMatch term cache) = object ["must" .= term,
2128 "_cache" .= cache]
2129 toJSON (MustNotMatch term cache) = object ["must_not" .= term,
2130 "_cache" .= cache]
2131 toJSON (ShouldMatch terms cache) = object ["should" .= fmap toJSON terms,
2132 "_cache" .= cache]
2135instance (FromJSON a) => FromJSON (SearchResult a) where
2136 parseJSON (Object v) = SearchResult <$>
2137 v .: "took" <*>
2138 v .: "timed_out" <*>
2139 v .: "_shards" <*>
2140 v .: "hits" <*>
2141 v .:? "aggregations"
2142 parseJSON _ = empty
2144instance (FromJSON a) => FromJSON (SearchHits a) where
2145 parseJSON (Object v) = SearchHits <$>
2146 v .: "total" <*>
2147 v .: "max_score" <*>
2148 v .: "hits"
2149 parseJSON _ = empty
2151instance (FromJSON a) => FromJSON (Hit a) where
2152 parseJSON (Object v) = Hit <$>
2153 v .: "_index" <*>
2154 v .: "_type" <*>
2155 v .: "_id" <*>
2156 v .: "_score" <*>
2157 v .: "_source" <*>
2158 v .:? "highlight"
2159 parseJSON _ = empty
2161instance FromJSON ShardResult where
2162 parseJSON (Object v) = ShardResult <$>
2163 v .: "total" <*>
2164 v .: "successful" <*>
2165 v .: "failed"
2166 parseJSON _ = empty