src/Database/Bloodhound/Types.hs · typeable/bloodhound

git.iko.soy/typeable/bloodhound

on aeson-0.10 help sign in

typeable/bloodhound/src/Database/Bloodhound/Types.hs

2447 lines 91 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

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 , defaultIndexDocumentSettings

33 , mkSort

34 , showText

35 , unpackId

36 , mkMatchQuery

37 , mkMultiMatchQuery

38 , mkBoolQuery

39 , mkRangeQuery

40 , mkQueryStringQuery

41 , mkAggregations

42 , mkTermsAggregation

43 , mkTermsScriptAggregation

44 , mkDateHistogram

45 , mkDocVersion

46 , docVersionNumber

47 , toTerms

48 , toDateHistogram

49 , omitNulls

50 , BH(..)

51 , runBH

52 , BHEnv(..)

53 , MonadBH(..)

54 , Version(..)

55 , Status(..)

56 , Existence(..)

57 , NullValue(..)

58 , IndexSettings(..)

59 , IndexTemplate(..)

60 , Server(..)

61 , Reply

62 , EsResult(..)

63 , EsResultFound(..)

64 , EsError(..)

65 , DocVersion

66 , ExternalDocVersion(..)

67 , VersionControl(..)

68 , DocumentParent(..)

69 , IndexDocumentSettings(..)

70 , Query(..)

71 , Search(..)

72 , SearchType(..)

73 , SearchResult(..)

74 , ScrollId

75 , SearchHits(..)

76 , TrackSortScores

77 , From(..)

78 , Size(..)

79 , Source(..)

80 , PatternOrPatterns(..)

81 , Include(..)

82 , Exclude(..)

83 , Pattern(..)

84 , ShardResult(..)

85 , Hit(..)

86 , Filter(..)

87 , Seminearring(..)

88 , BoolMatch(..)

89 , Term(..)

90 , GeoPoint(..)

91 , GeoBoundingBoxConstraint(..)

92 , GeoBoundingBox(..)

93 , GeoFilterType(..)

94 , Distance(..)

95 , DistanceUnit(..)

96 , DistanceType(..)

97 , DistanceRange(..)

98 , OptimizeBbox(..)

99 , LatLon(..)

100 , RangeValue(..)

101 , RangeExecution(..)

102 , LessThan(..)

103 , LessThanEq(..)

104 , GreaterThan(..)

105 , GreaterThanEq(..)

106 , LessThanD(..)

107 , LessThanEqD(..)

108 , GreaterThanD(..)

109 , GreaterThanEqD(..)

110 , Regexp(..)

111 , RegexpFlags(..)

112 , RegexpFlag(..)

113 , FieldName(..)

114 , Script(..)

115 , IndexName(..)

116 , TemplateName(..)

117 , TemplatePattern(..)

118 , MappingName(..)

119 , DocId(..)

120 , CacheName(..)

121 , CacheKey(..)

122 , BulkOperation(..)

123 , ReplicaCount(..)

124 , ShardCount(..)

125 , Sort

126 , SortMode(..)

127 , SortOrder(..)

128 , SortSpec(..)

129 , DefaultSort(..)

130 , Missing(..)

131 , OpenCloseIndex(..)

132 , Method

133 , Boost(..)

134 , MatchQuery(..)

135 , MultiMatchQuery(..)

136 , BoolQuery(..)

137 , BoostingQuery(..)

138 , CommonTermsQuery(..)

139 , DisMaxQuery(..)

140 , FilteredQuery(..)

141 , FuzzyLikeThisQuery(..)

142 , FuzzyLikeFieldQuery(..)

143 , FuzzyQuery(..)

144 , HasChildQuery(..)

145 , HasParentQuery(..)

146 , IndicesQuery(..)

147 , MoreLikeThisQuery(..)

148 , MoreLikeThisFieldQuery(..)

149 , NestedQuery(..)

150 , PrefixQuery(..)

151 , QueryStringQuery(..)

152 , SimpleQueryStringQuery(..)

153 , RangeQuery(..)

154 , RegexpQuery(..)

155 , QueryString(..)

156 , BooleanOperator(..)

157 , ZeroTermsQuery(..)

158 , CutoffFrequency(..)

159 , Analyzer(..)

160 , MaxExpansions(..)

161 , Lenient(..)

162 , MatchQueryType(..)

163 , MultiMatchQueryType(..)

164 , Tiebreaker(..)

165 , MinimumMatch(..)

166 , DisableCoord(..)

167 , CommonMinimumMatch(..)

168 , MinimumMatchHighLow(..)

169 , PrefixLength(..)

170 , Fuzziness(..)

171 , IgnoreTermFrequency(..)

172 , MaxQueryTerms(..)

173 , ScoreType(..)

174 , Score

175 , Cache

176 , TypeName(..)

177 , BoostTerms(..)

178 , MaxWordLength(..)

179 , MinWordLength(..)

180 , MaxDocFrequency(..)

181 , MinDocFrequency(..)

182 , PhraseSlop(..)

183 , StopWord(..)

184 , QueryPath(..)

185 , MinimumTermFrequency(..)

186 , PercentMatch(..)

187 , FieldDefinition(..)

188 , MappingField(..)

189 , Mapping(..)

190 , AllowLeadingWildcard(..)

191 , LowercaseExpanded(..)

192 , GeneratePhraseQueries(..)

193 , Locale(..)

194 , AnalyzeWildcard(..)

195 , EnablePositionIncrements(..)

196 , SimpleQueryFlag(..)

197 , FieldOrFields(..)

198 , Monoid(..)

199 , ToJSON(..)

200 , Interval(..)

201 , TimeInterval(..)

202 , ExecutionHint(..)

203 , CollectionMode(..)

204 , TermOrder(..)

205 , TermInclusion(..)

206

207 , Aggregation(..)

208 , Aggregations

209 , AggregationResults

210 , Bucket(..)

211 , BucketAggregation(..)

212 , TermsAggregation(..)

213 , ValueCountAggregation(..)

214 , FilterAggregation(..)

215 , DateHistogramAggregation(..)

216

217 , Highlights(..)

218 , FieldHighlight(..)

219 , HighlightSettings(..)

220 , PlainHighlight(..)

221 , PostingsHighlight(..)

222 , FastVectorHighlight(..)

223 , CommonHighlight(..)

224 , NonPostings(..)

225 , HighlightEncoder(..)

226 , HighlightTag(..)

227 , HitHighlight

228

229 , TermsResult(..)

230 , DateHistogramResult(..)

231 ) where

232

233import Control.Applicative

234import Control.Monad.Catch

235import Control.Monad.Except

236import Control.Monad.Reader

237import Control.Monad.State

238import Control.Monad.Writer

239import Data.Aeson

240import Data.Aeson.Types (Pair, emptyObject, parseMaybe)

241import qualified Data.ByteString.Lazy.Char8 as L

242import qualified Data.HashMap.Strict as HM (union)

243import Data.List (foldl', nub)

244import Data.List.NonEmpty (NonEmpty (..), toList)

245import qualified Data.Map.Strict as M

246import Data.Maybe

247import Data.Text (Text)

248import qualified Data.Text as T

249import Data.Time.Clock (UTCTime)

250import qualified Data.Vector as V

251import GHC.Enum

252import GHC.Generics (Generic)

253import Network.HTTP.Client

254import qualified Network.HTTP.Types.Method as NHTM

255

256import Database.Bloodhound.Types.Class

257

258-- $setup

259-- >>> :set -XOverloadedStrings

260-- >>> import Database.Bloodhound

261-- >>> let testServer = (Server "http://localhost:9200")

262-- >>> let testIndex = IndexName "twitter"

263-- >>> let testMapping = MappingName "tweet"

264-- >>> let defaultIndexSettings = IndexSettings (ShardCount 3) (ReplicaCount 2)

265

266-- defaultIndexSettings is exported by Database.Bloodhound as well

267-- no trailing slashes in servers, library handles building the path.

268

269{-| Common environment for Elasticsearch calls. Connections will be

270 pipelined according to the provided HTTP connection manager.

271-}

272data BHEnv = BHEnv { bhServer :: Server

273 , bhManager :: Manager

274 }

275

276{-| All API calls to Elasticsearch operate within

277 MonadBH. The idea is that it can be easily embedded in your

278 own monad transformer stack. A default instance for a ReaderT and

279 alias 'BH' is provided for the simple case.

280-}

281class (Functor m, Applicative m, MonadIO m) => MonadBH m where

282 getBHEnv :: m BHEnv

283

284newtype BH m a = BH {

285 unBH :: ReaderT BHEnv m a

286 } deriving ( Functor

287 , Applicative

288 , Monad

289 , MonadIO

290 , MonadState s

291 , MonadWriter w

292 , MonadError e

293 , Alternative

294 , MonadPlus

295 , MonadFix

296 , MonadThrow

297 , MonadCatch

298 , MonadMask)

299

300instance MonadTrans BH where

301 lift = BH . lift

302

303instance (MonadReader r m) => MonadReader r (BH m) where

304 ask = lift ask

305 local f (BH (ReaderT m)) = BH $ ReaderT $ \r ->

306 local f (m r)

307

308instance (Functor m, Applicative m, MonadIO m) => MonadBH (BH m) where

309 getBHEnv = BH getBHEnv

310

311

312instance (Functor m, Applicative m, MonadIO m) => MonadBH (ReaderT BHEnv m) where

313 getBHEnv = ask

314

315runBH :: BHEnv -> BH m a -> m a

316runBH e f = runReaderT (unBH f) e

317

318{-| 'Version' is embedded in 'Status' -}

319data Version = Version { number :: Text

320 , build_hash :: Text

321 , build_timestamp :: UTCTime

322 , build_snapshot :: Bool

323 , lucene_version :: Text } deriving (Eq, Show, Generic)

324

325{-| 'Status' is a data type for describing the JSON body returned by

326 Elasticsearch when you query its status. This was deprecated in 1.2.0.

327

328 <http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-status.html#indices-status>

329-}

330

331data Status = Status { ok :: Maybe Bool

332 , status :: Int

333 , name :: Text

334 , version :: Version

335 , tagline :: Text } deriving (Eq, Show)

336

337{-| 'IndexSettings' is used to configure the shards and replicas when you create

338 an Elasticsearch Index.

339

340 <http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-create-index.html>

341-}

342

343data IndexSettings =

344 IndexSettings { indexShards :: ShardCount

345 , indexReplicas :: ReplicaCount } deriving (Eq, Show)

346

347{-| 'defaultIndexSettings' is an 'IndexSettings' with 3 shards and 2 replicas. -}

348defaultIndexSettings :: IndexSettings

349defaultIndexSettings = IndexSettings (ShardCount 3) (ReplicaCount 2)

350

351{-| 'Reply' and 'Method' are type synonyms from 'Network.HTTP.Types.Method.Method' -}

352type Reply = Network.HTTP.Client.Response L.ByteString

353type Method = NHTM.Method

354

355{-| 'OpenCloseIndex' is a sum type for opening and closing indices.

356

357 <http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-open-close.html>

358-}

359data OpenCloseIndex = OpenIndex | CloseIndex deriving (Eq, Show)

360

361data FieldType = GeoPointType

362 | GeoShapeType

363 | FloatType

364 | IntegerType

365 | LongType

366 | ShortType

367 | ByteType deriving (Eq, Show)

368

369data FieldDefinition =

370 FieldDefinition { fieldType :: FieldType } deriving (Eq, Show)

371

372{-| An 'IndexTemplate' defines a template that will automatically be

373 applied to new indices created. The templates include both

374 'IndexSettings' and mappings, and a simple 'TemplatePattern' that

375 controls if the template will be applied to the index created.

376 Specify mappings as follows: @[toJSON TweetMapping, ...]@

377

378 https://www.elastic.co/guide/en/elasticsearch/reference/1.7/indices-templates.html

379-}

380data IndexTemplate =

381 IndexTemplate { templatePattern :: TemplatePattern

382 , templateSettings :: Maybe IndexSettings

383 , templateMappings :: [Value]

384 }

385

386data MappingField =

387 MappingField { mappingFieldName :: FieldName

388 , fieldDefinition :: FieldDefinition } deriving (Eq, Show)

389

390{-| Support for type reification of 'Mapping's is currently incomplete, for

391 now the mapping API verbiage expects a 'ToJSON'able blob.

392

393 Indexes have mappings, mappings are schemas for the documents contained in the

394 index. I'd recommend having only one mapping per index, always having a mapping,

395 and keeping different kinds of documents separated if possible.

396-}

397data Mapping = Mapping { typeName :: TypeName

398 , mappingFields :: [MappingField] } deriving (Eq, Show)

399

400{-| 'BulkOperation' is a sum type for expressing the four kinds of bulk

401 operation index, create, delete, and update. 'BulkIndex' behaves like an

402 "upsert", 'BulkCreate' will fail if a document already exists at the DocId.

403

404 <http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-bulk.html#docs-bulk>

405-}

406data BulkOperation =

407 BulkIndex IndexName MappingName DocId Value

408 | BulkCreate IndexName MappingName DocId Value

409 | BulkDelete IndexName MappingName DocId

410 | BulkUpdate IndexName MappingName DocId Value deriving (Eq, Show)

411

412{-| 'EsResult' describes the standard wrapper JSON document that you see in

413 successful Elasticsearch lookups or lookups that couldn't find the document.

414-}

415data EsResult a = EsResult { _index :: Text

416 , _type :: Text

417 , _id :: Text

418 , foundResult :: Maybe (EsResultFound a)} deriving (Eq, Show)

419

420{-| 'EsResultFound' contains the document and its metadata inside of an

421 'EsResult' when the document was successfully found.

422-}

423data EsResultFound a = EsResultFound { _version :: DocVersion

424 , _source :: a } deriving (Eq, Show)

425

426{-| 'EsError' is the generic type that will be returned when there was a

427 problem. If you can't parse the expected response, its a good idea to

428 try parsing this.

429-}

430data EsError = EsError { errorStatus :: Int

431 , errorMessage :: Text } deriving (Eq, Show)

432

433

434{-| 'DocVersion' is an integer version number for a document between 1

435and 9.2e+18 used for <<https://www.elastic.co/guide/en/elasticsearch/guide/current/optimistic-concurrency-control.html optimistic concurrency control>>.

436-}

437newtype DocVersion = DocVersion {

438 docVersionNumber :: Int

439 } deriving (Eq, Show, Ord, ToJSON)

440

441-- | Smart constructor for in-range doc version

442mkDocVersion :: Int -> Maybe DocVersion

443mkDocVersion i

444 | i >= (docVersionNumber minBound) && i <= (docVersionNumber maxBound) =

445 Just $ DocVersion i

446 | otherwise = Nothing

447

448

449{-| 'ExternalDocVersion' is a convenience wrapper if your code uses its

450own version numbers instead of ones from ES.

451-}

452newtype ExternalDocVersion = ExternalDocVersion DocVersion

453 deriving (Eq, Show, Ord, Bounded, Enum, ToJSON)

454

455{-| 'VersionControl' is specified when indexing documents as a

456optimistic concurrency control.

457-}

458data VersionControl = NoVersionControl

459 -- ^ Don't send a version. This is a pure overwrite.

460 | InternalVersion DocVersion

461 -- ^ Use the default ES versioning scheme. Only

462 -- index the document if the version is the same

463 -- as the one specified. Only applicable to

464 -- updates, as you should be getting Version from

465 -- a search result.

466 | ExternalGT ExternalDocVersion

467 -- ^ Use your own version numbering. Only index

468 -- the document if the version is strictly higher

469 -- OR the document doesn't exist. The given

470 -- version will be used as the new version number

471 -- for the stored document. N.B. All updates must

472 -- increment this number, meaning there is some

473 -- global, external ordering of updates.

474 | ExternalGTE ExternalDocVersion

475 -- ^ Use your own version numbering. Only index

476 -- the document if the version is equal or higher

477 -- than the stored version. Will succeed if there

478 -- is no existing document. The given version will

479 -- be used as the new version number for the

480 -- stored document. Use with care, as this could

481 -- result in data loss.

482 | ForceVersion ExternalDocVersion

483 -- ^ The document will always be indexed and the

484 -- given version will be the new version. This is

485 -- typically used for correcting errors. Use with

486 -- care, as this could result in data loss.

487 deriving (Show, Eq, Ord)

488

489{-| 'DocumentParent' is used to specify a parent document.

490-}

491newtype DocumentParent = DocumentParent DocId

492 deriving (Eq, Show)

493

494{-| 'IndexDocumentSettings' are special settings supplied when indexing

495a document. For the best backwards compatiblity when new fields are

496added, you should probably prefer to start with 'defaultIndexDocumentSettings'

497-}

498data IndexDocumentSettings =

499 IndexDocumentSettings { idsVersionControl :: VersionControl

500 , idsParent :: Maybe DocumentParent

501 } deriving (Eq, Show)

502

503{-| Reasonable default settings. Chooses no version control and no parent.

504-}

505defaultIndexDocumentSettings :: IndexDocumentSettings

506defaultIndexDocumentSettings = IndexDocumentSettings NoVersionControl Nothing

507

508{-| 'Sort' is a synonym for a list of 'SortSpec's. Sort behavior is order

509 dependent with later sorts acting as tie-breakers for earlier sorts.

510-}

511type Sort = [SortSpec]

512

513{-| The two main kinds of 'SortSpec' are 'DefaultSortSpec' and

514 'GeoDistanceSortSpec'. The latter takes a 'SortOrder', 'GeoPoint', and

515 'DistanceUnit' to express "nearness" to a single geographical point as a

516 sort specification.

517

518<http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html#search-request-sort>

519-}

520data SortSpec = DefaultSortSpec DefaultSort

521 | GeoDistanceSortSpec SortOrder GeoPoint DistanceUnit deriving (Eq, Show)

522

523{-| 'DefaultSort' is usually the kind of 'SortSpec' you'll want. There's a

524 'mkSort' convenience function for when you want to specify only the most

525 common parameters.

526

527<http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html#search-request-sort>

528-}

529data DefaultSort =

530 DefaultSort { sortFieldName :: FieldName

531 , sortOrder :: SortOrder

532 -- default False

533 , ignoreUnmapped :: Bool

534 , sortMode :: Maybe SortMode

535 , missingSort :: Maybe Missing

536 , nestedFilter :: Maybe Filter } deriving (Eq, Show)

537

538{-| 'SortOrder' is 'Ascending' or 'Descending', as you might expect. These get

539 encoded into "asc" or "desc" when turned into JSON.

540

541<http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html#search-request-sort>

542-}

543data SortOrder = Ascending

544 | Descending deriving (Eq, Show)

545

546{-| 'Missing' prescribes how to handle missing fields. A missing field can be

547 sorted last, first, or using a custom value as a substitute.

548

549<http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html#_missing_values>

550-}

551data Missing = LastMissing

552 | FirstMissing

553 | CustomMissing Text deriving (Eq, Show)

554

555{-| 'SortMode' prescribes how to handle sorting array/multi-valued fields.

556

557http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html#_sort_mode_option

558-}

559data SortMode = SortMin

560 | SortMax

561 | SortSum

562 | SortAvg deriving (Eq, Show)

563

564{-| 'mkSort' defaults everything but the 'FieldName' and the 'SortOrder' so

565 that you can concisely describe the usual kind of 'SortSpec's you want.

566-}

567mkSort :: FieldName -> SortOrder -> DefaultSort

568mkSort fieldName sOrder = DefaultSort fieldName sOrder False Nothing Nothing Nothing

569

570{-| 'Cache' is for telling ES whether it should cache a 'Filter' not.

571 'Query's cannot be cached.

572-}

573type Cache = Bool -- caching on/off

574defaultCache :: Cache

575defaultCache = False

576

577{-| 'PrefixValue' is used in 'PrefixQuery' as the main query component.

578-}

579type PrefixValue = Text

580

581{-| 'BooleanOperator' is the usual And/Or operators with an ES compatible

582 JSON encoding baked in. Used all over the place.

583-}

584data BooleanOperator = And | Or deriving (Eq, Show)

585

586{-| 'ShardCount' is part of 'IndexSettings'

587-}

588newtype ShardCount = ShardCount Int deriving (Eq, Show, Generic)

589

590{-| 'ReplicaCount' is part of 'IndexSettings'

591-}

592newtype ReplicaCount = ReplicaCount Int deriving (Eq, Show, Generic)

593

594{-| 'Server' is used with the client functions to point at the ES instance

595-}

596newtype Server = Server Text deriving (Eq, Show)

597

598{-| 'IndexName' is used to describe which index to query/create/delete

599-}

600newtype IndexName = IndexName Text deriving (Eq, Generic, Show)

601

602{-| 'TemplateName' is used to describe which template to query/create/delete

603-}

604newtype TemplateName = TemplateName Text deriving (Eq, Show, Generic)

605

606{-| 'TemplatePattern' represents a pattern which is matched against index names

607-}

608newtype TemplatePattern = TemplatePattern Text deriving (Eq, Show, Generic)

609

610{-| 'MappingName' is part of mappings which are how ES describes and schematizes

611 the data in the indices.

612-}

613newtype MappingName = MappingName Text deriving (Eq, Generic, Show)

614

615{-| 'DocId' is a generic wrapper value for expressing unique Document IDs.

616 Can be set by the user or created by ES itself. Often used in client

617 functions for poking at specific documents.

618-}

619newtype DocId = DocId Text deriving (Eq, Generic, Show)

620

621{-| 'QueryString' is used to wrap query text bodies, be they human written or not.

622-}

623newtype QueryString = QueryString Text deriving (Eq, Generic, Show)

624

625{-| 'FieldName' is used all over the place wherever a specific field within

626 a document needs to be specified, usually in 'Query's or 'Filter's.

627-}

628newtype FieldName = FieldName Text deriving (Eq, Show)

629

630

631{-| 'Script' is often used in place of 'FieldName' to specify more

632complex ways of extracting a value from a document.

633-}

634newtype Script = Script { scriptText :: Text } deriving (Eq, Show)

635

636{-| 'CacheName' is used in 'RegexpFilter' for describing the

637 'CacheKey' keyed caching behavior.

638-}

639newtype CacheName = CacheName Text deriving (Eq, Show)

640

641{-| 'CacheKey' is used in 'RegexpFilter' to key regex caching.

642-}

643newtype CacheKey =

644 CacheKey Text deriving (Eq, Show)

645newtype Existence =

646 Existence Bool deriving (Eq, Show)

647newtype NullValue =

648 NullValue Bool deriving (Eq, Show)

649newtype CutoffFrequency =

650 CutoffFrequency Double deriving (Eq, Show, Generic)

651newtype Analyzer =

652 Analyzer Text deriving (Eq, Show, Generic)

653newtype MaxExpansions =

654 MaxExpansions Int deriving (Eq, Show, Generic)

655

656{-| 'Lenient', if set to true, will cause format based failures to be

657 ignored. I don't know what the bloody default is, Elasticsearch

658 documentation didn't say what it was. Let me know if you figure it out.

659-}

660newtype Lenient =

661 Lenient Bool deriving (Eq, Show, Generic)

662newtype Tiebreaker =

663 Tiebreaker Double deriving (Eq, Show, Generic)

664newtype Boost =

665 Boost Double deriving (Eq, Show, Generic)

666newtype BoostTerms =

667 BoostTerms Double deriving (Eq, Show, Generic)

668

669{-| 'MinimumMatch' controls how many should clauses in the bool query should

670 match. Can be an absolute value (2) or a percentage (30%) or a

671 combination of both.

672-}

673newtype MinimumMatch =

674 MinimumMatch Int deriving (Eq, Show, Generic)

675newtype MinimumMatchText =

676 MinimumMatchText Text deriving (Eq, Show)

677newtype DisableCoord =

678 DisableCoord Bool deriving (Eq, Show, Generic)

679newtype IgnoreTermFrequency =

680 IgnoreTermFrequency Bool deriving (Eq, Show, Generic)

681newtype MinimumTermFrequency =

682 MinimumTermFrequency Int deriving (Eq, Show, Generic)

683newtype MaxQueryTerms =

684 MaxQueryTerms Int deriving (Eq, Show, Generic)

685newtype Fuzziness =

686 Fuzziness Double deriving (Eq, Show, Generic)

687

688{-| 'PrefixLength' is the prefix length used in queries, defaults to 0. -}

689newtype PrefixLength =

690 PrefixLength Int deriving (Eq, Show, Generic)

691newtype TypeName =

692 TypeName Text deriving (Eq, Show, Generic)

693newtype PercentMatch =

694 PercentMatch Double deriving (Eq, Show, Generic)

695newtype StopWord =

696 StopWord Text deriving (Eq, Show, Generic)

697newtype QueryPath =

698 QueryPath Text deriving (Eq, Show, Generic)

699

700{-| Allowing a wildcard at the beginning of a word (eg "*ing") is particularly

701 heavy, because all terms in the index need to be examined, just in case

702 they match. Leading wildcards can be disabled by setting

703 'AllowLeadingWildcard' to false. -}

704newtype AllowLeadingWildcard =

705 AllowLeadingWildcard Bool deriving (Eq, Show, Generic)

706newtype LowercaseExpanded =

707 LowercaseExpanded Bool deriving (Eq, Show, Generic)

708newtype EnablePositionIncrements =

709 EnablePositionIncrements Bool deriving (Eq, Show, Generic)

710

711{-| By default, wildcard terms in a query are not analyzed.

712 Setting 'AnalyzeWildcard' to true enables best-effort analysis.

713-}

714newtype AnalyzeWildcard = AnalyzeWildcard Bool deriving (Eq, Show, Generic)

715

716{-| 'GeneratePhraseQueries' defaults to false.

717-}

718newtype GeneratePhraseQueries =

719 GeneratePhraseQueries Bool deriving (Eq, Show, Generic)

720

721{-| 'Locale' is used for string conversions - defaults to ROOT.

722-}

723newtype Locale = Locale Text deriving (Eq, Show, Generic)

724newtype MaxWordLength = MaxWordLength Int deriving (Eq, Show, Generic)

725newtype MinWordLength = MinWordLength Int deriving (Eq, Show, Generic)

726

727{-| 'PhraseSlop' sets the default slop for phrases, 0 means exact

728 phrase matches. Default is 0.

729-}

730newtype PhraseSlop = PhraseSlop Int deriving (Eq, Show, Generic)

731newtype MinDocFrequency = MinDocFrequency Int deriving (Eq, Show, Generic)

732newtype MaxDocFrequency = MaxDocFrequency Int deriving (Eq, Show, Generic)

733

734{-| 'unpackId' is a silly convenience function that gets used once.

735-}

736unpackId :: DocId -> Text

737unpackId (DocId docId) = docId

738

739type TrackSortScores = Bool

740newtype From = From Int deriving (Eq, Show, ToJSON)

741newtype Size = Size Int deriving (Eq, Show, ToJSON)

742

743data Search = Search { queryBody :: Maybe Query

744 , filterBody :: Maybe Filter

745 , sortBody :: Maybe Sort

746 , aggBody :: Maybe Aggregations

747 , highlight :: Maybe Highlights

748 -- default False

749 , trackSortScores :: TrackSortScores

750 , from :: From

751 , size :: Size

752 , searchType :: SearchType

753 , fields :: Maybe [FieldName]

754 , source :: Maybe Source } deriving (Eq, Show)

755

756data SearchType = SearchTypeQueryThenFetch

757 | SearchTypeDfsQueryThenFetch

758 | SearchTypeCount

759 | SearchTypeScan

760 | SearchTypeQueryAndFetch

761 | SearchTypeDfsQueryAndFetch

762 deriving (Eq, Show)

763

764data Source =

765 NoSource

766 | SourcePatterns PatternOrPatterns

767 | SourceIncludeExclude Include Exclude

768 deriving (Show, Eq)

769

770data PatternOrPatterns = PopPattern Pattern

771 | PopPatterns [Pattern] deriving (Eq, Show)

772

773data Include = Include [Pattern] deriving (Eq, Show)

774data Exclude = Exclude [Pattern] deriving (Eq, Show)

775

776newtype Pattern = Pattern Text deriving (Eq, Show)

777

778data Highlights = Highlights { globalsettings :: Maybe HighlightSettings

779 , highlightFields :: [FieldHighlight]

780 } deriving (Show, Eq)

781

782data FieldHighlight = FieldHighlight FieldName (Maybe HighlightSettings)

783 deriving (Show, Eq)

784

785

786data HighlightSettings = Plain PlainHighlight

787 | Postings PostingsHighlight

788 | FastVector FastVectorHighlight

789 deriving (Show, Eq)

790data PlainHighlight =

791 PlainHighlight { plainCommon :: Maybe CommonHighlight

792 , plainNonPost :: Maybe NonPostings } deriving (Show, Eq)

793

794 -- This requires that index_options are set to 'offset' in the mapping.

795data PostingsHighlight = PostingsHighlight (Maybe CommonHighlight) deriving (Show, Eq)

796

797-- This requires that term_vector is set to 'with_positions_offsets' in the mapping.

798data FastVectorHighlight =

799 FastVectorHighlight { fvCommon :: Maybe CommonHighlight

800 , fvNonPostSettings :: Maybe NonPostings

801 , boundaryChars :: Maybe Text

802 , boundaryMaxScan :: Maybe Int

803 , fragmentOffset :: Maybe Int

804 , matchedFields :: [Text]

805 , phraseLimit :: Maybe Int

806 } deriving (Show, Eq)

807

808data CommonHighlight =

809 CommonHighlight { order :: Maybe Text

810 , forceSource :: Maybe Bool

811 , tag :: Maybe HighlightTag

812 , encoder :: Maybe HighlightEncoder

813 , noMatchSize :: Maybe Int

814 , highlightQuery :: Maybe Query

815 , requireFieldMatch :: Maybe Bool

816 } deriving (Show, Eq)

817

818-- Settings that are only applicable to FastVector and Plain highlighters.

819data NonPostings =

820 NonPostings { fragmentSize :: Maybe Int

821 , numberOfFragments :: Maybe Int} deriving (Show, Eq)

822

823data HighlightEncoder = DefaultEncoder

824 | HTMLEncoder

825 deriving (Show, Eq)

826

827-- NOTE: Should the tags use some kind of HTML type, rather than Text?

828data HighlightTag = TagSchema Text

829 | CustomTags ([Text], [Text]) -- Only uses more than the first value in the lists if fvh

830 deriving (Show, Eq)

831

832

833data Query =

834 TermQuery Term (Maybe Boost)

835 | TermsQuery (NonEmpty Term)

836 | QueryMatchQuery MatchQuery

837 | QueryMultiMatchQuery MultiMatchQuery

838 | QueryBoolQuery BoolQuery

839 | QueryBoostingQuery BoostingQuery

840 | QueryCommonTermsQuery CommonTermsQuery

841 | ConstantScoreFilter Filter Boost

842 | ConstantScoreQuery Query Boost

843 | QueryDisMaxQuery DisMaxQuery

844 | QueryFilteredQuery FilteredQuery

845 | QueryFuzzyLikeThisQuery FuzzyLikeThisQuery

846 | QueryFuzzyLikeFieldQuery FuzzyLikeFieldQuery

847 | QueryFuzzyQuery FuzzyQuery

848 | QueryHasChildQuery HasChildQuery

849 | QueryHasParentQuery HasParentQuery

850 | IdsQuery MappingName [DocId]

851 | QueryIndicesQuery IndicesQuery

852 | MatchAllQuery (Maybe Boost)

853 | QueryMoreLikeThisQuery MoreLikeThisQuery

854 | QueryMoreLikeThisFieldQuery MoreLikeThisFieldQuery

855 | QueryNestedQuery NestedQuery

856 | QueryPrefixQuery PrefixQuery

857 | QueryQueryStringQuery QueryStringQuery

858 | QuerySimpleQueryStringQuery SimpleQueryStringQuery

859 | QueryRangeQuery RangeQuery

860 | QueryRegexpQuery RegexpQuery

861 deriving (Eq, Show)

862

863data RegexpQuery =

864 RegexpQuery { regexpQueryField :: FieldName

865 , regexpQuery :: Regexp

866 , regexpQueryFlags :: RegexpFlags

867 , regexpQueryBoost :: Maybe Boost

868 } deriving (Eq, Show)

869

870data RangeQuery =

871 RangeQuery { rangeQueryField :: FieldName

872 , rangeQueryRange :: RangeValue

873 , rangeQueryBoost :: Boost } deriving (Eq, Show)

874

875mkRangeQuery :: FieldName -> RangeValue -> RangeQuery

876mkRangeQuery f r = RangeQuery f r (Boost 1.0)

877

878data SimpleQueryStringQuery =

879 SimpleQueryStringQuery

880 { simpleQueryStringQuery :: QueryString

881 , simpleQueryStringField :: Maybe FieldOrFields

882 , simpleQueryStringOperator :: Maybe BooleanOperator

883 , simpleQueryStringAnalyzer :: Maybe Analyzer

884 , simpleQueryStringFlags :: Maybe [SimpleQueryFlag]

885 , simpleQueryStringLowercaseExpanded :: Maybe LowercaseExpanded

886 , simpleQueryStringLocale :: Maybe Locale

887 } deriving (Eq, Show)

888

889data SimpleQueryFlag =

890 SimpleQueryAll

891 | SimpleQueryNone

892 | SimpleQueryAnd

893 | SimpleQueryOr

894 | SimpleQueryPrefix

895 | SimpleQueryPhrase

896 | SimpleQueryPrecedence

897 | SimpleQueryEscape

898 | SimpleQueryWhitespace

899 | SimpleQueryFuzzy

900 | SimpleQueryNear

901 | SimpleQuerySlop deriving (Eq, Show)

902

903-- use_dis_max and tie_breaker when fields are plural?

904data QueryStringQuery =

905 QueryStringQuery

906 { queryStringQuery :: QueryString

907 , queryStringDefaultField :: Maybe FieldName

908 , queryStringOperator :: Maybe BooleanOperator

909 , queryStringAnalyzer :: Maybe Analyzer

910 , queryStringAllowLeadingWildcard :: Maybe AllowLeadingWildcard

911 , queryStringLowercaseExpanded :: Maybe LowercaseExpanded

912 , queryStringEnablePositionIncrements :: Maybe EnablePositionIncrements

913 , queryStringFuzzyMaxExpansions :: Maybe MaxExpansions

914 , queryStringFuzziness :: Maybe Fuzziness

915 , queryStringFuzzyPrefixLength :: Maybe PrefixLength

916 , queryStringPhraseSlop :: Maybe PhraseSlop

917 , queryStringBoost :: Maybe Boost

918 , queryStringAnalyzeWildcard :: Maybe AnalyzeWildcard

919 , queryStringGeneratePhraseQueries :: Maybe GeneratePhraseQueries

920 , queryStringMinimumShouldMatch :: Maybe MinimumMatch

921 , queryStringLenient :: Maybe Lenient

922 , queryStringLocale :: Maybe Locale

923 } deriving (Eq, Show)

924

925mkQueryStringQuery :: QueryString -> QueryStringQuery

926mkQueryStringQuery qs =

927 QueryStringQuery qs Nothing Nothing

928 Nothing Nothing Nothing Nothing

929 Nothing Nothing Nothing Nothing

930 Nothing Nothing Nothing Nothing

931 Nothing Nothing

932

933data FieldOrFields = FofField FieldName

934 | FofFields [FieldName] deriving (Eq, Show)

935

936data PrefixQuery =

937 PrefixQuery

938 { prefixQueryField :: FieldName

939 , prefixQueryPrefixValue :: Text

940 , prefixQueryBoost :: Maybe Boost } deriving (Eq, Show)

941

942data NestedQuery =

943 NestedQuery

944 { nestedQueryPath :: QueryPath

945 , nestedQueryScoreType :: ScoreType

946 , nestedQuery :: Query } deriving (Eq, Show)

947

948data MoreLikeThisFieldQuery =

949 MoreLikeThisFieldQuery

950 { moreLikeThisFieldText :: Text

951 , moreLikeThisFieldFields :: FieldName

952 -- default 0.3 (30%)

953 , moreLikeThisFieldPercentMatch :: Maybe PercentMatch

954 , moreLikeThisFieldMinimumTermFreq :: Maybe MinimumTermFrequency

955 , moreLikeThisFieldMaxQueryTerms :: Maybe MaxQueryTerms

956 , moreLikeThisFieldStopWords :: Maybe [StopWord]

957 , moreLikeThisFieldMinDocFrequency :: Maybe MinDocFrequency

958 , moreLikeThisFieldMaxDocFrequency :: Maybe MaxDocFrequency

959 , moreLikeThisFieldMinWordLength :: Maybe MinWordLength

960 , moreLikeThisFieldMaxWordLength :: Maybe MaxWordLength

961 , moreLikeThisFieldBoostTerms :: Maybe BoostTerms

962 , moreLikeThisFieldBoost :: Maybe Boost

963 , moreLikeThisFieldAnalyzer :: Maybe Analyzer

964 } deriving (Eq, Show)

965

966data MoreLikeThisQuery =

967 MoreLikeThisQuery

968 { moreLikeThisText :: Text

969 , moreLikeThisFields :: Maybe [FieldName]

970 -- default 0.3 (30%)

971 , moreLikeThisPercentMatch :: Maybe PercentMatch

972 , moreLikeThisMinimumTermFreq :: Maybe MinimumTermFrequency

973 , moreLikeThisMaxQueryTerms :: Maybe MaxQueryTerms

974 , moreLikeThisStopWords :: Maybe [StopWord]

975 , moreLikeThisMinDocFrequency :: Maybe MinDocFrequency

976 , moreLikeThisMaxDocFrequency :: Maybe MaxDocFrequency

977 , moreLikeThisMinWordLength :: Maybe MinWordLength

978 , moreLikeThisMaxWordLength :: Maybe MaxWordLength

979 , moreLikeThisBoostTerms :: Maybe BoostTerms

980 , moreLikeThisBoost :: Maybe Boost

981 , moreLikeThisAnalyzer :: Maybe Analyzer

982 } deriving (Eq, Show)

983

984data IndicesQuery =

985 IndicesQuery

986 { indicesQueryIndices :: [IndexName]

987 , indicesQuery :: Query

988 -- default "all"

989 , indicesQueryNoMatch :: Maybe Query } deriving (Eq, Show)

990

991data HasParentQuery =

992 HasParentQuery

993 { hasParentQueryType :: TypeName

994 , hasParentQuery :: Query

995 , hasParentQueryScoreType :: Maybe ScoreType } deriving (Eq, Show)

996

997data HasChildQuery =

998 HasChildQuery

999 { hasChildQueryType :: TypeName

1000 , hasChildQuery :: Query

1001 , hasChildQueryScoreType :: Maybe ScoreType } deriving (Eq, Show)

1002

1003data ScoreType =

1004 ScoreTypeMax

1005 | ScoreTypeSum

1006 | ScoreTypeAvg

1007 | ScoreTypeNone deriving (Eq, Show)

1008

1009data FuzzyQuery =

1010 FuzzyQuery { fuzzyQueryField :: FieldName

1011 , fuzzyQueryValue :: Text

1012 , fuzzyQueryPrefixLength :: PrefixLength

1013 , fuzzyQueryMaxExpansions :: MaxExpansions

1014 , fuzzyQueryFuzziness :: Fuzziness

1015 , fuzzyQueryBoost :: Maybe Boost

1016 } deriving (Eq, Show)

1017

1018data FuzzyLikeFieldQuery =

1019 FuzzyLikeFieldQuery

1020 { fuzzyLikeField :: FieldName

1021 -- anaphora is good for the soul.

1022 , fuzzyLikeFieldText :: Text

1023 , fuzzyLikeFieldMaxQueryTerms :: MaxQueryTerms

1024 , fuzzyLikeFieldIgnoreTermFrequency :: IgnoreTermFrequency

1025 , fuzzyLikeFieldFuzziness :: Fuzziness

1026 , fuzzyLikeFieldPrefixLength :: PrefixLength

1027 , fuzzyLikeFieldBoost :: Boost

1028 , fuzzyLikeFieldAnalyzer :: Maybe Analyzer

1029 } deriving (Eq, Show)

1030

1031data FuzzyLikeThisQuery =

1032 FuzzyLikeThisQuery

1033 { fuzzyLikeFields :: [FieldName]

1034 , fuzzyLikeText :: Text

1035 , fuzzyLikeMaxQueryTerms :: MaxQueryTerms

1036 , fuzzyLikeIgnoreTermFrequency :: IgnoreTermFrequency

1037 , fuzzyLikeFuzziness :: Fuzziness

1038 , fuzzyLikePrefixLength :: PrefixLength

1039 , fuzzyLikeBoost :: Boost

1040 , fuzzyLikeAnalyzer :: Maybe Analyzer

1041 } deriving (Eq, Show)

1042

1043data FilteredQuery =

1044 FilteredQuery

1045 { filteredQuery :: Query

1046 , filteredFilter :: Filter } deriving (Eq, Show)

1047

1048data DisMaxQuery =

1049 DisMaxQuery { disMaxQueries :: [Query]

1050 -- default 0.0

1051 , disMaxTiebreaker :: Tiebreaker

1052 , disMaxBoost :: Maybe Boost

1053 } deriving (Eq, Show)

1054

1055data MatchQuery =

1056 MatchQuery { matchQueryField :: FieldName

1057 , matchQueryQueryString :: QueryString

1058 , matchQueryOperator :: BooleanOperator

1059 , matchQueryZeroTerms :: ZeroTermsQuery

1060 , matchQueryCutoffFrequency :: Maybe CutoffFrequency

1061 , matchQueryMatchType :: Maybe MatchQueryType

1062 , matchQueryAnalyzer :: Maybe Analyzer

1063 , matchQueryMaxExpansions :: Maybe MaxExpansions

1064 , matchQueryLenient :: Maybe Lenient

1065 , matchQueryBoost :: Maybe Boost } deriving (Eq, Show)

1066

1067{-| 'mkMatchQuery' is a convenience function that defaults the less common parameters,

1068 enabling you to provide only the 'FieldName' and 'QueryString' to make a 'MatchQuery'

1069-}

1070mkMatchQuery :: FieldName -> QueryString -> MatchQuery

1071mkMatchQuery field query = MatchQuery field query Or ZeroTermsNone Nothing Nothing Nothing Nothing Nothing Nothing

1072

1073data MatchQueryType =

1074 MatchPhrase

1075 | MatchPhrasePrefix deriving (Eq, Show)

1076

1077data MultiMatchQuery =

1078 MultiMatchQuery { multiMatchQueryFields :: [FieldName]

1079 , multiMatchQueryString :: QueryString

1080 , multiMatchQueryOperator :: BooleanOperator

1081 , multiMatchQueryZeroTerms :: ZeroTermsQuery

1082 , multiMatchQueryTiebreaker :: Maybe Tiebreaker

1083 , multiMatchQueryType :: Maybe MultiMatchQueryType

1084 , multiMatchQueryCutoffFrequency :: Maybe CutoffFrequency

1085 , multiMatchQueryAnalyzer :: Maybe Analyzer

1086 , multiMatchQueryMaxExpansions :: Maybe MaxExpansions

1087 , multiMatchQueryLenient :: Maybe Lenient } deriving (Eq, Show)

1088

1089{-| 'mkMultiMatchQuery' is a convenience function that defaults the less common parameters,

1090 enabling you to provide only the list of 'FieldName's and 'QueryString' to

1091 make a 'MultiMatchQuery'.

1092-}

1093

1094mkMultiMatchQuery :: [FieldName] -> QueryString -> MultiMatchQuery

1095mkMultiMatchQuery matchFields query =

1096 MultiMatchQuery matchFields query

1097 Or ZeroTermsNone Nothing Nothing Nothing Nothing Nothing Nothing

1098

1099data MultiMatchQueryType =

1100 MultiMatchBestFields

1101 | MultiMatchMostFields

1102 | MultiMatchCrossFields

1103 | MultiMatchPhrase

1104 | MultiMatchPhrasePrefix deriving (Eq, Show)

1105

1106data BoolQuery =

1107 BoolQuery { boolQueryMustMatch :: [Query]

1108 , boolQueryMustNotMatch :: [Query]

1109 , boolQueryShouldMatch :: [Query]

1110 , boolQueryMinimumShouldMatch :: Maybe MinimumMatch

1111 , boolQueryBoost :: Maybe Boost

1112 , boolQueryDisableCoord :: Maybe DisableCoord

1113 } deriving (Eq, Show)

1114

1115mkBoolQuery :: [Query] -> [Query] -> [Query] -> BoolQuery

1116mkBoolQuery must mustNot should =

1117 BoolQuery must mustNot should Nothing Nothing Nothing

1118

1119data BoostingQuery =

1120 BoostingQuery { positiveQuery :: Query

1121 , negativeQuery :: Query

1122 , negativeBoost :: Boost } deriving (Eq, Show)

1123

1124data CommonTermsQuery =

1125 CommonTermsQuery { commonField :: FieldName

1126 , commonQuery :: QueryString

1127 , commonCutoffFrequency :: CutoffFrequency

1128 , commonLowFreqOperator :: BooleanOperator

1129 , commonHighFreqOperator :: BooleanOperator

1130 , commonMinimumShouldMatch :: Maybe CommonMinimumMatch

1131 , commonBoost :: Maybe Boost

1132 , commonAnalyzer :: Maybe Analyzer

1133 , commonDisableCoord :: Maybe DisableCoord

1134 } deriving (Eq, Show)

1135

1136data CommonMinimumMatch =

1137 CommonMinimumMatchHighLow MinimumMatchHighLow

1138 | CommonMinimumMatch MinimumMatch

1139 deriving (Eq, Show)

1140

1141data MinimumMatchHighLow =

1142 MinimumMatchHighLow { lowFreq :: MinimumMatch

1143 , highFreq :: MinimumMatch } deriving (Eq, Show)

1144

1145data Filter = AndFilter [Filter] Cache

1146 | OrFilter [Filter] Cache

1147 | NotFilter Filter Cache

1148 | IdentityFilter

1149 | BoolFilter BoolMatch

1150 | ExistsFilter FieldName -- always cached

1151 | GeoBoundingBoxFilter GeoBoundingBoxConstraint

1152 | GeoDistanceFilter GeoPoint Distance DistanceType OptimizeBbox Cache

1153 | GeoDistanceRangeFilter GeoPoint DistanceRange

1154 | GeoPolygonFilter FieldName [LatLon]

1155 | IdsFilter MappingName [DocId]

1156 | LimitFilter Int

1157 | MissingFilter FieldName Existence NullValue

1158 | PrefixFilter FieldName PrefixValue Cache

1159 | QueryFilter Query Cache

1160 | RangeFilter FieldName RangeValue RangeExecution Cache

1161 | RegexpFilter FieldName Regexp RegexpFlags CacheName Cache CacheKey

1162 | TermFilter Term Cache

1163 deriving (Eq, Show)

1164

1165data ZeroTermsQuery = ZeroTermsNone

1166 | ZeroTermsAll deriving (Eq, Show)

1167

1168data RangeExecution = RangeExecutionIndex

1169 | RangeExecutionFielddata deriving (Eq, Show)

1170

1171newtype Regexp = Regexp Text deriving (Eq, Show)

1172

1173data RegexpFlags = AllRegexpFlags

1174 | NoRegexpFlags

1175 | SomeRegexpFlags (NonEmpty RegexpFlag) deriving (Eq, Show)

1176

1177data RegexpFlag = AnyString

1178 | Automaton

1179 | Complement

1180 | Empty

1181 | Intersection

1182 | Interval deriving (Eq, Show)

1183

1184newtype LessThan = LessThan Double deriving (Eq, Show)

1185newtype LessThanEq = LessThanEq Double deriving (Eq, Show)

1186newtype GreaterThan = GreaterThan Double deriving (Eq, Show)

1187newtype GreaterThanEq = GreaterThanEq Double deriving (Eq, Show)

1188

1189newtype LessThanD = LessThanD UTCTime deriving (Eq, Show)

1190newtype LessThanEqD = LessThanEqD UTCTime deriving (Eq, Show)

1191newtype GreaterThanD = GreaterThanD UTCTime deriving (Eq, Show)

1192newtype GreaterThanEqD = GreaterThanEqD UTCTime deriving (Eq, Show)

1193

1194data RangeValue = RangeDateLte LessThanEqD

1195 | RangeDateLt LessThanD

1196 | RangeDateGte GreaterThanEqD

1197 | RangeDateGt GreaterThanD

1198 | RangeDateGtLt GreaterThanD LessThanD

1199 | RangeDateGteLte GreaterThanEqD LessThanEqD

1200 | RangeDateGteLt GreaterThanEqD LessThanD

1201 | RangeDateGtLte GreaterThanD LessThanEqD

1202 | RangeDoubleLte LessThanEq

1203 | RangeDoubleLt LessThan

1204 | RangeDoubleGte GreaterThanEq

1205 | RangeDoubleGt GreaterThan

1206 | RangeDoubleGtLt GreaterThan LessThan

1207 | RangeDoubleGteLte GreaterThanEq LessThanEq

1208 | RangeDoubleGteLt GreaterThanEq LessThan

1209 | RangeDoubleGtLte GreaterThan LessThanEq

1210 deriving (Eq, Show)

1211

1212rangeValueToPair :: RangeValue -> [Pair]

1213rangeValueToPair rv = case rv of

1214 RangeDateLte (LessThanEqD t) -> ["lte" .= t]

1215 RangeDateGte (GreaterThanEqD t) -> ["gte" .= t]

1216 RangeDateLt (LessThanD t) -> ["lt" .= t]

1217 RangeDateGt (GreaterThanD t) -> ["gt" .= t]

1218 RangeDateGteLte (GreaterThanEqD l) (LessThanEqD g) -> ["gte" .= l, "lte" .= g]

1219 RangeDateGtLte (GreaterThanD l) (LessThanEqD g) -> ["gt" .= l, "lte" .= g]

1220 RangeDateGteLt (GreaterThanEqD l) (LessThanD g) -> ["gte" .= l, "lt" .= g]

1221 RangeDateGtLt (GreaterThanD l) (LessThanD g) -> ["gt" .= l, "lt" .= g]

1222 RangeDoubleLte (LessThanEq t) -> ["lte" .= t]

1223 RangeDoubleGte (GreaterThanEq t) -> ["gte" .= t]

1224 RangeDoubleLt (LessThan t) -> ["lt" .= t]

1225 RangeDoubleGt (GreaterThan t) -> ["gt" .= t]

1226 RangeDoubleGteLte (GreaterThanEq l) (LessThanEq g) -> ["gte" .= l, "lte" .= g]

1227 RangeDoubleGtLte (GreaterThan l) (LessThanEq g) -> ["gt" .= l, "lte" .= g]

1228 RangeDoubleGteLt (GreaterThanEq l) (LessThan g) -> ["gte" .= l, "lt" .= g]

1229 RangeDoubleGtLt (GreaterThan l) (LessThan g) -> ["gt" .= l, "lt" .= g]

1230

1231data Term = Term { termField :: Text

1232 , termValue :: Text } deriving (Eq, Show)

1233

1234data BoolMatch = MustMatch Term Cache

1235 | MustNotMatch Term Cache

1236 | ShouldMatch [Term] Cache deriving (Eq, Show)

1237

1238-- "memory" or "indexed"

1239data GeoFilterType = GeoFilterMemory

1240 | GeoFilterIndexed deriving (Eq, Show)

1241

1242data LatLon = LatLon { lat :: Double

1243 , lon :: Double } deriving (Eq, Show)

1244

1245data GeoBoundingBox =

1246 GeoBoundingBox { topLeft :: LatLon

1247 , bottomRight :: LatLon } deriving (Eq, Show)

1248

1249data GeoBoundingBoxConstraint =

1250 GeoBoundingBoxConstraint { geoBBField :: FieldName

1251 , constraintBox :: GeoBoundingBox

1252 , bbConstraintcache :: Cache

1253 , geoType :: GeoFilterType

1254 } deriving (Eq, Show)

1255

1256data GeoPoint =

1257 GeoPoint { geoField :: FieldName

1258 , latLon :: LatLon} deriving (Eq, Show)

1259

1260data DistanceUnit = Miles

1261 | Yards

1262 | Feet

1263 | Inches

1264 | Kilometers

1265 | Meters

1266 | Centimeters

1267 | Millimeters

1268 | NauticalMiles deriving (Eq, Show)

1269

1270data DistanceType = Arc

1271 | SloppyArc -- doesn't exist <1.0

1272 | Plane deriving (Eq, Show)

1273

1274data OptimizeBbox = OptimizeGeoFilterType GeoFilterType

1275 | NoOptimizeBbox deriving (Eq, Show)

1276

1277data Distance =

1278 Distance { coefficient :: Double

1279 , unit :: DistanceUnit } deriving (Eq, Show)

1280

1281data DistanceRange =

1282 DistanceRange { distanceFrom :: Distance

1283 , distanceTo :: Distance } deriving (Eq, Show)

1284

1285data SearchResult a =

1286 SearchResult { took :: Int

1287 , timedOut :: Bool

1288 , shards :: ShardResult

1289 , searchHits :: SearchHits a

1290 , aggregations :: Maybe AggregationResults

1291 , scrollId :: Maybe ScrollId } deriving (Eq, Show)

1292

1293type ScrollId = Text -- Fixme: Newtype

1294

1295type Score = Maybe Double

1296

1297data SearchHits a =

1298 SearchHits { hitsTotal :: Int

1299 , maxScore :: Score

1300 , hits :: [Hit a] } deriving (Eq, Show)

1301

1302

1303instance Monoid (SearchHits a) where

1304 mempty = SearchHits 0 Nothing mempty

1305 mappend (SearchHits ta ma ha) (SearchHits tb mb hb) =

1306 SearchHits (ta + tb) (max ma mb) (ha <> hb)

1307

1308

1309data Hit a =

1310 Hit { hitIndex :: IndexName

1311 , hitType :: MappingName

1312 , hitDocId :: DocId

1313 , hitScore :: Score

1314 , hitSource :: Maybe a

1315 , hitHighlight :: Maybe HitHighlight } deriving (Eq, Show)

1316

1317data ShardResult =

1318 ShardResult { shardTotal :: Int

1319 , shardsSuccessful :: Int

1320 , shardsFailed :: Int } deriving (Eq, Show, Generic)

1321

1322type HitHighlight = M.Map Text [Text]

1323

1324showText :: Show a => a -> Text

1325showText = T.pack . show

1326

1327type Aggregations = M.Map Text Aggregation

1328

1329emptyAggregations :: Aggregations

1330emptyAggregations = M.empty

1331

1332mkAggregations :: Text -> Aggregation -> Aggregations

1333mkAggregations name aggregation = M.insert name aggregation emptyAggregations

1334

1335data TermOrder = TermOrder{ termSortField :: Text

1336 , termSortOrder :: SortOrder } deriving (Eq, Show)

1337

1338data TermInclusion = TermInclusion Text

1339 | TermPattern Text Text deriving (Eq, Show)

1340

1341data CollectionMode = BreadthFirst

1342 | DepthFirst deriving (Eq, Show)

1343

1344data ExecutionHint = Ordinals

1345 | GlobalOrdinals

1346 | GlobalOrdinalsHash

1347 | GlobalOrdinalsLowCardinality

1348 | Map deriving (Eq, Show)

1349

1350data TimeInterval = Weeks

1351 | Days

1352 | Hours

1353 | Minutes

1354 | Seconds deriving (Eq)

1355

1356data Interval = Year

1357 | Quarter

1358 | Month

1359 | Week

1360 | Day

1361 | Hour

1362 | Minute

1363 | Second

1364 | FractionalInterval Float TimeInterval deriving (Eq, Show)

1365

1366data Aggregation = TermsAgg TermsAggregation

1367 | DateHistogramAgg DateHistogramAggregation

1368 | ValueCountAgg ValueCountAggregation

1369 | FilterAgg FilterAggregation deriving (Eq, Show)

1370

1371

1372data TermsAggregation = TermsAggregation { term :: Either Text Text

1373 , termInclude :: Maybe TermInclusion

1374 , termExclude :: Maybe TermInclusion

1375 , termOrder :: Maybe TermOrder

1376 , termMinDocCount :: Maybe Int

1377 , termSize :: Maybe Int

1378 , termShardSize :: Maybe Int

1379 , termCollectMode :: Maybe CollectionMode

1380 , termExecutionHint :: Maybe ExecutionHint

1381 , termAggs :: Maybe Aggregations

1382 } deriving (Eq, Show)

1383

1384data DateHistogramAggregation = DateHistogramAggregation { dateField :: FieldName

1385 , dateInterval :: Interval

1386 , dateFormat :: Maybe Text

1387 -- pre and post deprecated in 1.5

1388 , datePreZone :: Maybe Text

1389 , datePostZone :: Maybe Text

1390 , datePreOffset :: Maybe Text

1391 , datePostOffset :: Maybe Text

1392 , dateAggs :: Maybe Aggregations

1393 } deriving (Eq, Show)

1394

1395-- | See <https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-metrics-valuecount-aggregation.html> for more information.

1396data ValueCountAggregation = FieldValueCount FieldName

1397 | ScriptValueCount Script deriving (Eq, Show)

1398

1399-- | 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.

1400data FilterAggregation = FilterAggregation { faFilter :: Filter

1401 , faAggs :: Maybe Aggregations} deriving (Eq, Show)

1402

1403mkTermsAggregation :: Text -> TermsAggregation