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

git.iko.soy/typeable/bloodhound

on v0.8.0.0 help sign in

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

2435 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 , DocVersion

65 , ExternalDocVersion(..)

66 , VersionControl(..)

67 , DocumentParent(..)

68 , IndexDocumentSettings(..)

69 , Query(..)

70 , Search(..)

71 , SearchType(..)

72 , SearchResult(..)

73 , ScrollId

74 , SearchHits(..)

75 , TrackSortScores

76 , From(..)

77 , Size(..)

78 , Source(..)

79 , PatternOrPatterns(..)

80 , Include(..)

81 , Exclude(..)

82 , Pattern(..)

83 , ShardResult(..)

84 , Hit(..)

85 , Filter(..)

86 , Seminearring(..)

87 , BoolMatch(..)

88 , Term(..)

89 , GeoPoint(..)

90 , GeoBoundingBoxConstraint(..)

91 , GeoBoundingBox(..)

92 , GeoFilterType(..)

93 , Distance(..)

94 , DistanceUnit(..)

95 , DistanceType(..)

96 , DistanceRange(..)

97 , OptimizeBbox(..)

98 , LatLon(..)

99 , RangeValue(..)

100 , RangeExecution(..)

101 , LessThan(..)

102 , LessThanEq(..)

103 , GreaterThan(..)

104 , GreaterThanEq(..)

105 , LessThanD(..)

106 , LessThanEqD(..)

107 , GreaterThanD(..)

108 , GreaterThanEqD(..)

109 , Regexp(..)

110 , RegexpFlags(..)

111 , RegexpFlag(..)

112 , FieldName(..)

113 , Script(..)

114 , IndexName(..)

115 , TemplateName(..)

116 , TemplatePattern(..)

117 , MappingName(..)

118 , DocId(..)

119 , CacheName(..)

120 , CacheKey(..)

121 , BulkOperation(..)

122 , ReplicaCount(..)

123 , ShardCount(..)

124 , Sort

125 , SortMode(..)

126 , SortOrder(..)

127 , SortSpec(..)

128 , DefaultSort(..)

129 , Missing(..)

130 , OpenCloseIndex(..)

131 , Method

132 , Boost(..)

133 , MatchQuery(..)

134 , MultiMatchQuery(..)

135 , BoolQuery(..)

136 , BoostingQuery(..)

137 , CommonTermsQuery(..)

138 , DisMaxQuery(..)

139 , FilteredQuery(..)

140 , FuzzyLikeThisQuery(..)

141 , FuzzyLikeFieldQuery(..)

142 , FuzzyQuery(..)

143 , HasChildQuery(..)

144 , HasParentQuery(..)

145 , IndicesQuery(..)

146 , MoreLikeThisQuery(..)

147 , MoreLikeThisFieldQuery(..)

148 , NestedQuery(..)

149 , PrefixQuery(..)

150 , QueryStringQuery(..)

151 , SimpleQueryStringQuery(..)

152 , RangeQuery(..)

153 , RegexpQuery(..)

154 , QueryString(..)

155 , BooleanOperator(..)

156 , ZeroTermsQuery(..)

157 , CutoffFrequency(..)

158 , Analyzer(..)

159 , MaxExpansions(..)

160 , Lenient(..)

161 , MatchQueryType(..)

162 , MultiMatchQueryType(..)

163 , Tiebreaker(..)

164 , MinimumMatch(..)

165 , DisableCoord(..)

166 , CommonMinimumMatch(..)

167 , MinimumMatchHighLow(..)

168 , PrefixLength(..)

169 , Fuzziness(..)

170 , IgnoreTermFrequency(..)

171 , MaxQueryTerms(..)

172 , ScoreType(..)

173 , Score

174 , Cache

175 , TypeName(..)

176 , BoostTerms(..)

177 , MaxWordLength(..)

178 , MinWordLength(..)

179 , MaxDocFrequency(..)

180 , MinDocFrequency(..)

181 , PhraseSlop(..)

182 , StopWord(..)

183 , QueryPath(..)

184 , MinimumTermFrequency(..)

185 , PercentMatch(..)

186 , FieldDefinition(..)

187 , MappingField(..)

188 , Mapping(..)

189 , AllowLeadingWildcard(..)

190 , LowercaseExpanded(..)

191 , GeneratePhraseQueries(..)

192 , Locale(..)

193 , AnalyzeWildcard(..)

194 , EnablePositionIncrements(..)

195 , SimpleQueryFlag(..)

196 , FieldOrFields(..)

197 , Monoid(..)

198 , ToJSON(..)

199 , Interval(..)

200 , TimeInterval(..)

201 , ExecutionHint(..)

202 , CollectionMode(..)

203 , TermOrder(..)

204 , TermInclusion(..)

205

206 , Aggregation(..)

207 , Aggregations

208 , AggregationResults

209 , Bucket(..)

210 , BucketAggregation(..)

211 , TermsAggregation(..)

212 , ValueCountAggregation(..)

213 , FilterAggregation(..)

214 , DateHistogramAggregation(..)

215

216 , Highlights(..)

217 , FieldHighlight(..)

218 , HighlightSettings(..)

219 , PlainHighlight(..)

220 , PostingsHighlight(..)

221 , FastVectorHighlight(..)

222 , CommonHighlight(..)

223 , NonPostings(..)

224 , HighlightEncoder(..)

225 , HighlightTag(..)

226 , HitHighlight

227

228 , TermsResult(..)

229 , DateHistogramResult(..)

230 ) where

231

232import Control.Applicative

233import Control.Monad.Catch

234import Control.Monad.Except

235import Control.Monad.Reader

236import Control.Monad.State

237import Control.Monad.Writer

238import Data.Aeson

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

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

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

242import Data.List (foldl', nub)

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

244import qualified Data.Map.Strict as M

245import Data.Maybe

246import Data.Text (Text)

247import qualified Data.Text as T

248import Data.Time.Clock (UTCTime)

249import qualified Data.Vector as V

250import GHC.Enum

251import GHC.Generics (Generic)

252import Network.HTTP.Client

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

254

255import Database.Bloodhound.Types.Class

256

257-- $setup

258-- >>> :set -XOverloadedStrings

259-- >>> import Database.Bloodhound

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

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

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

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

264

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

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

267

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

269 pipelined according to the provided HTTP connection manager.

270-}

271data BHEnv = BHEnv { bhServer :: Server

272 , bhManager :: Manager

273 }

274

275{-| All API calls to Elasticsearch operate within

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

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

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

279-}

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

281 getBHEnv :: m BHEnv

282

283newtype BH m a = BH {

284 unBH :: ReaderT BHEnv m a

285 } deriving ( Functor

286 , Applicative

287 , Monad

288 , MonadIO

289 , MonadState s

290 , MonadWriter w

291 , MonadError e

292 , Alternative

293 , MonadPlus

294 , MonadFix

295 , MonadThrow

296 , MonadCatch

297 , MonadMask)

298

299instance MonadTrans BH where

300 lift = BH . lift

301

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

303 ask = lift ask

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

305 local f (m r)

306

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

308 getBHEnv = BH getBHEnv

309

310

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

312 getBHEnv = ask

313

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

315runBH e f = runReaderT (unBH f) e

316

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

318data Version = Version { number :: Text

319 , build_hash :: Text

320 , build_timestamp :: UTCTime

321 , build_snapshot :: Bool

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

323

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

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

326

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

328-}

329

330data Status = Status { ok :: Maybe Bool

331 , status :: Int

332 , name :: Text

333 , version :: Version

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

335

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

337 an Elasticsearch Index.

338

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

340-}

341

342data IndexSettings =

343 IndexSettings { indexShards :: ShardCount

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

345

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

347defaultIndexSettings :: IndexSettings

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

349

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

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

352type Method = NHTM.Method

353

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

355

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

357-}

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

359

360data FieldType = GeoPointType

361 | GeoShapeType

362 | FloatType

363 | IntegerType

364 | LongType

365 | ShortType

366 | ByteType deriving (Eq, Show)

367

368data FieldDefinition =

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

370

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

372 applied to new indices created. The templates include both

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

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

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

376

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

378-}

379data IndexTemplate =

380 IndexTemplate { templatePattern :: TemplatePattern

381 , templateSettings :: Maybe IndexSettings

382 , templateMappings :: [Value]

383 }

384

385data MappingField =

386 MappingField { mappingFieldName :: FieldName

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

388

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

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

391

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

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

394 and keeping different kinds of documents separated if possible.

395-}

396data Mapping = Mapping { typeName :: TypeName

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

398

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

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

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

402

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

404-}

405data BulkOperation =

406 BulkIndex IndexName MappingName DocId Value

407 | BulkCreate IndexName MappingName DocId Value

408 | BulkDelete IndexName MappingName DocId

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

410

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

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

413-}

414data EsResult a = EsResult { _index :: Text

415 , _type :: Text

416 , _id :: Text

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

418

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

427

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

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

430-}

431newtype DocVersion = DocVersion {

432 docVersionNumber :: Int

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

434

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

436mkDocVersion :: Int -> Maybe DocVersion

437mkDocVersion i

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

439 Just $ DocVersion i

440 | otherwise = Nothing

441

442

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

444own version numbers instead of ones from ES.

445-}

446newtype ExternalDocVersion = ExternalDocVersion DocVersion

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

448

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

450optimistic concurrency control.

451-}

452data VersionControl = NoVersionControl

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

454 | InternalVersion DocVersion

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

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

457 -- as the one specified. Only applicable to

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

459 -- a search result.

460 | ExternalGT ExternalDocVersion

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

462 -- the document if the version is strictly higher

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

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

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

466 -- increment this number, meaning there is some

467 -- global, external ordering of updates.

468 | ExternalGTE ExternalDocVersion

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

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

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

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

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

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

475 -- result in data loss.

476 | ForceVersion ExternalDocVersion

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

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

479 -- typically used for correcting errors. Use with

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

481 deriving (Show, Eq, Ord)

482

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

484-}

485newtype DocumentParent = DocumentParent DocId

486 deriving (Eq, Show)

487

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

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

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

491-}

492data IndexDocumentSettings =

493 IndexDocumentSettings { idsVersionControl :: VersionControl

494 , idsParent :: Maybe DocumentParent

495 } deriving (Eq, Show)

496

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

498-}

499defaultIndexDocumentSettings :: IndexDocumentSettings

500defaultIndexDocumentSettings = IndexDocumentSettings NoVersionControl Nothing

501

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

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

504-}

505type Sort = [SortSpec]

506

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

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

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

510 sort specification.

511

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

513-}

514data SortSpec = DefaultSortSpec DefaultSort

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

516

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

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

519 common parameters.

520

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

522-}

523data DefaultSort =

524 DefaultSort { sortFieldName :: FieldName

525 , sortOrder :: SortOrder

526 -- default False

527 , ignoreUnmapped :: Bool

528 , sortMode :: Maybe SortMode

529 , missingSort :: Maybe Missing

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

531

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

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

534

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

536-}

537data SortOrder = Ascending

538 | Descending deriving (Eq, Show)

539

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

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

542

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

544-}

545data Missing = LastMissing

546 | FirstMissing

547 | CustomMissing Text deriving (Eq, Show)

548

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

550

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

552-}

553data SortMode = SortMin

554 | SortMax

555 | SortSum

556 | SortAvg deriving (Eq, Show)

557

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

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

560-}

561mkSort :: FieldName -> SortOrder -> DefaultSort

562mkSort fieldName sOrder = DefaultSort fieldName sOrder False Nothing Nothing Nothing

563

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

565 'Query's cannot be cached.

566-}

567type Cache = Bool -- caching on/off

568defaultCache :: Cache

569defaultCache = False

570

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

572-}

573type PrefixValue = Text

574

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

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

577-}

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

579

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

581-}

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

583

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

585-}

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

587

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

589-}

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

591

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

593-}

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

595

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

597-}

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

599

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

601-}

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

603

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

605 the data in the indices.

606-}

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

608

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

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

611 functions for poking at specific documents.

612-}

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

614

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

616-}

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

618

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

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

621-}

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

623

624

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

626complex ways of extracting a value from a document.

627-}

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

629

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

631 'CacheKey' keyed caching behavior.

632-}

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

634

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

636-}

637newtype CacheKey =

638 CacheKey Text deriving (Eq, Show)

639newtype Existence =

640 Existence Bool deriving (Eq, Show)

641newtype NullValue =

642 NullValue Bool deriving (Eq, Show)

643newtype CutoffFrequency =

644 CutoffFrequency Double deriving (Eq, Show, Generic)

645newtype Analyzer =

646 Analyzer Text deriving (Eq, Show, Generic)

647newtype MaxExpansions =

648 MaxExpansions Int deriving (Eq, Show, Generic)

649

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

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

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

653-}

654newtype Lenient =

655 Lenient Bool deriving (Eq, Show, Generic)

656newtype Tiebreaker =

657 Tiebreaker Double deriving (Eq, Show, Generic)

658newtype Boost =

659 Boost Double deriving (Eq, Show, Generic)

660newtype BoostTerms =

661 BoostTerms Double deriving (Eq, Show, Generic)

662

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

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

665 combination of both.

666-}

667newtype MinimumMatch =

668 MinimumMatch Int deriving (Eq, Show, Generic)

669newtype MinimumMatchText =

670 MinimumMatchText Text deriving (Eq, Show)

671newtype DisableCoord =

672 DisableCoord Bool deriving (Eq, Show, Generic)

673newtype IgnoreTermFrequency =

674 IgnoreTermFrequency Bool deriving (Eq, Show, Generic)

675newtype MinimumTermFrequency =

676 MinimumTermFrequency Int deriving (Eq, Show, Generic)

677newtype MaxQueryTerms =

678 MaxQueryTerms Int deriving (Eq, Show, Generic)

679newtype Fuzziness =

680 Fuzziness Double deriving (Eq, Show, Generic)

681

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

683newtype PrefixLength =

684 PrefixLength Int deriving (Eq, Show, Generic)

685newtype TypeName =

686 TypeName Text deriving (Eq, Show, Generic)

687newtype PercentMatch =

688 PercentMatch Double deriving (Eq, Show, Generic)

689newtype StopWord =

690 StopWord Text deriving (Eq, Show, Generic)

691newtype QueryPath =

692 QueryPath Text deriving (Eq, Show, Generic)

693

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

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

696 they match. Leading wildcards can be disabled by setting

697 'AllowLeadingWildcard' to false. -}

698newtype AllowLeadingWildcard =

699 AllowLeadingWildcard Bool deriving (Eq, Show, Generic)

700newtype LowercaseExpanded =

701 LowercaseExpanded Bool deriving (Eq, Show, Generic)

702newtype EnablePositionIncrements =

703 EnablePositionIncrements Bool deriving (Eq, Show, Generic)

704

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

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

707-}

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

709

710{-| 'GeneratePhraseQueries' defaults to false.

711-}

712newtype GeneratePhraseQueries =

713 GeneratePhraseQueries Bool deriving (Eq, Show, Generic)

714

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

716-}

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

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

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

720

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

722 phrase matches. Default is 0.

723-}

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

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

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

727

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

729-}

730unpackId :: DocId -> Text

731unpackId (DocId docId) = docId

732

733type TrackSortScores = Bool

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

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

736

737data Search = Search { queryBody :: Maybe Query

738 , filterBody :: Maybe Filter

739 , sortBody :: Maybe Sort

740 , aggBody :: Maybe Aggregations

741 , highlight :: Maybe Highlights

742 -- default False

743 , trackSortScores :: TrackSortScores

744 , from :: From

745 , size :: Size

746 , searchType :: SearchType

747 , fields :: Maybe [FieldName]

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

749

750data SearchType = SearchTypeQueryThenFetch

751 | SearchTypeDfsQueryThenFetch

752 | SearchTypeCount

753 | SearchTypeScan

754 | SearchTypeQueryAndFetch

755 | SearchTypeDfsQueryAndFetch

756 deriving (Eq, Show)

757

758data Source =

759 NoSource

760 | SourcePatterns PatternOrPatterns

761 | SourceIncludeExclude Include Exclude

762 deriving (Show, Eq)

763

764data PatternOrPatterns = PopPattern Pattern

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

766

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

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

769

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

771

772data Highlights = Highlights { globalsettings :: Maybe HighlightSettings

773 , highlightFields :: [FieldHighlight]

774 } deriving (Show, Eq)

775

776data FieldHighlight = FieldHighlight FieldName (Maybe HighlightSettings)

777 deriving (Show, Eq)

778

779

780data HighlightSettings = Plain PlainHighlight

781 | Postings PostingsHighlight

782 | FastVector FastVectorHighlight

783 deriving (Show, Eq)

784data PlainHighlight =

785 PlainHighlight { plainCommon :: Maybe CommonHighlight

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

787

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

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

790

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

792data FastVectorHighlight =

793 FastVectorHighlight { fvCommon :: Maybe CommonHighlight

794 , fvNonPostSettings :: Maybe NonPostings

795 , boundaryChars :: Maybe Text

796 , boundaryMaxScan :: Maybe Int

797 , fragmentOffset :: Maybe Int

798 , matchedFields :: [Text]

799 , phraseLimit :: Maybe Int

800 } deriving (Show, Eq)

801

802data CommonHighlight =

803 CommonHighlight { order :: Maybe Text

804 , forceSource :: Maybe Bool

805 , tag :: Maybe HighlightTag

806 , encoder :: Maybe HighlightEncoder

807 , noMatchSize :: Maybe Int

808 , highlightQuery :: Maybe Query

809 , requireFieldMatch :: Maybe Bool

810 } deriving (Show, Eq)

811

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

813data NonPostings =

814 NonPostings { fragmentSize :: Maybe Int

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

816

817data HighlightEncoder = DefaultEncoder

818 | HTMLEncoder

819 deriving (Show, Eq)

820

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

822data HighlightTag = TagSchema Text

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

824 deriving (Show, Eq)

825

826

827data Query =

828 TermQuery Term (Maybe Boost)

829 | TermsQuery (NonEmpty Term)

830 | QueryMatchQuery MatchQuery

831 | QueryMultiMatchQuery MultiMatchQuery

832 | QueryBoolQuery BoolQuery

833 | QueryBoostingQuery BoostingQuery

834 | QueryCommonTermsQuery CommonTermsQuery

835 | ConstantScoreFilter Filter Boost

836 | ConstantScoreQuery Query Boost

837 | QueryDisMaxQuery DisMaxQuery

838 | QueryFilteredQuery FilteredQuery

839 | QueryFuzzyLikeThisQuery FuzzyLikeThisQuery

840 | QueryFuzzyLikeFieldQuery FuzzyLikeFieldQuery

841 | QueryFuzzyQuery FuzzyQuery

842 | QueryHasChildQuery HasChildQuery

843 | QueryHasParentQuery HasParentQuery

844 | IdsQuery MappingName [DocId]

845 | QueryIndicesQuery IndicesQuery

846 | MatchAllQuery (Maybe Boost)

847 | QueryMoreLikeThisQuery MoreLikeThisQuery

848 | QueryMoreLikeThisFieldQuery MoreLikeThisFieldQuery

849 | QueryNestedQuery NestedQuery

850 | QueryPrefixQuery PrefixQuery

851 | QueryQueryStringQuery QueryStringQuery

852 | QuerySimpleQueryStringQuery SimpleQueryStringQuery

853 | QueryRangeQuery RangeQuery

854 | QueryRegexpQuery RegexpQuery

855 deriving (Eq, Show)

856

857data RegexpQuery =

858 RegexpQuery { regexpQueryField :: FieldName

859 , regexpQuery :: Regexp

860 , regexpQueryFlags :: RegexpFlags

861 , regexpQueryBoost :: Maybe Boost

862 } deriving (Eq, Show)

863

864data RangeQuery =

865 RangeQuery { rangeQueryField :: FieldName

866 , rangeQueryRange :: RangeValue

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

868

869mkRangeQuery :: FieldName -> RangeValue -> RangeQuery

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

871

872data SimpleQueryStringQuery =

873 SimpleQueryStringQuery

874 { simpleQueryStringQuery :: QueryString

875 , simpleQueryStringField :: Maybe FieldOrFields

876 , simpleQueryStringOperator :: Maybe BooleanOperator

877 , simpleQueryStringAnalyzer :: Maybe Analyzer

878 , simpleQueryStringFlags :: Maybe [SimpleQueryFlag]

879 , simpleQueryStringLowercaseExpanded :: Maybe LowercaseExpanded

880 , simpleQueryStringLocale :: Maybe Locale

881 } deriving (Eq, Show)

882

883data SimpleQueryFlag =

884 SimpleQueryAll

885 | SimpleQueryNone

886 | SimpleQueryAnd

887 | SimpleQueryOr

888 | SimpleQueryPrefix

889 | SimpleQueryPhrase

890 | SimpleQueryPrecedence

891 | SimpleQueryEscape

892 | SimpleQueryWhitespace

893 | SimpleQueryFuzzy

894 | SimpleQueryNear

895 | SimpleQuerySlop deriving (Eq, Show)

896

897-- use_dis_max and tie_breaker when fields are plural?

898data QueryStringQuery =

899 QueryStringQuery

900 { queryStringQuery :: QueryString

901 , queryStringDefaultField :: Maybe FieldName

902 , queryStringOperator :: Maybe BooleanOperator

903 , queryStringAnalyzer :: Maybe Analyzer

904 , queryStringAllowLeadingWildcard :: Maybe AllowLeadingWildcard

905 , queryStringLowercaseExpanded :: Maybe LowercaseExpanded

906 , queryStringEnablePositionIncrements :: Maybe EnablePositionIncrements

907 , queryStringFuzzyMaxExpansions :: Maybe MaxExpansions

908 , queryStringFuzziness :: Maybe Fuzziness

909 , queryStringFuzzyPrefixLength :: Maybe PrefixLength

910 , queryStringPhraseSlop :: Maybe PhraseSlop

911 , queryStringBoost :: Maybe Boost

912 , queryStringAnalyzeWildcard :: Maybe AnalyzeWildcard

913 , queryStringGeneratePhraseQueries :: Maybe GeneratePhraseQueries

914 , queryStringMinimumShouldMatch :: Maybe MinimumMatch

915 , queryStringLenient :: Maybe Lenient

916 , queryStringLocale :: Maybe Locale

917 } deriving (Eq, Show)

918

919mkQueryStringQuery :: QueryString -> QueryStringQuery

920mkQueryStringQuery qs =

921 QueryStringQuery qs Nothing Nothing

922 Nothing Nothing Nothing Nothing

923 Nothing Nothing Nothing Nothing

924 Nothing Nothing Nothing Nothing

925 Nothing Nothing

926

927data FieldOrFields = FofField FieldName

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

929

930data PrefixQuery =

931 PrefixQuery

932 { prefixQueryField :: FieldName

933 , prefixQueryPrefixValue :: Text

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

935

936data NestedQuery =

937 NestedQuery

938 { nestedQueryPath :: QueryPath

939 , nestedQueryScoreType :: ScoreType

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

941

942data MoreLikeThisFieldQuery =

943 MoreLikeThisFieldQuery

944 { moreLikeThisFieldText :: Text

945 , moreLikeThisFieldFields :: FieldName

946 -- default 0.3 (30%)

947 , moreLikeThisFieldPercentMatch :: Maybe PercentMatch

948 , moreLikeThisFieldMinimumTermFreq :: Maybe MinimumTermFrequency

949 , moreLikeThisFieldMaxQueryTerms :: Maybe MaxQueryTerms

950 , moreLikeThisFieldStopWords :: Maybe [StopWord]

951 , moreLikeThisFieldMinDocFrequency :: Maybe MinDocFrequency

952 , moreLikeThisFieldMaxDocFrequency :: Maybe MaxDocFrequency

953 , moreLikeThisFieldMinWordLength :: Maybe MinWordLength

954 , moreLikeThisFieldMaxWordLength :: Maybe MaxWordLength

955 , moreLikeThisFieldBoostTerms :: Maybe BoostTerms

956 , moreLikeThisFieldBoost :: Maybe Boost

957 , moreLikeThisFieldAnalyzer :: Maybe Analyzer

958 } deriving (Eq, Show)

959

960data MoreLikeThisQuery =

961 MoreLikeThisQuery

962 { moreLikeThisText :: Text

963 , moreLikeThisFields :: Maybe [FieldName]

964 -- default 0.3 (30%)

965 , moreLikeThisPercentMatch :: Maybe PercentMatch

966 , moreLikeThisMinimumTermFreq :: Maybe MinimumTermFrequency

967 , moreLikeThisMaxQueryTerms :: Maybe MaxQueryTerms

968 , moreLikeThisStopWords :: Maybe [StopWord]

969 , moreLikeThisMinDocFrequency :: Maybe MinDocFrequency

970 , moreLikeThisMaxDocFrequency :: Maybe MaxDocFrequency

971 , moreLikeThisMinWordLength :: Maybe MinWordLength

972 , moreLikeThisMaxWordLength :: Maybe MaxWordLength

973 , moreLikeThisBoostTerms :: Maybe BoostTerms

974 , moreLikeThisBoost :: Maybe Boost

975 , moreLikeThisAnalyzer :: Maybe Analyzer

976 } deriving (Eq, Show)

977

978data IndicesQuery =

979 IndicesQuery

980 { indicesQueryIndices :: [IndexName]

981 , indicesQuery :: Query

982 -- default "all"

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

984

985data HasParentQuery =

986 HasParentQuery

987 { hasParentQueryType :: TypeName

988 , hasParentQuery :: Query

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

990

991data HasChildQuery =

992 HasChildQuery

993 { hasChildQueryType :: TypeName

994 , hasChildQuery :: Query

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

996

997data ScoreType =

998 ScoreTypeMax

999 | ScoreTypeSum

1000 | ScoreTypeAvg

1001 | ScoreTypeNone deriving (Eq, Show)

1002

1003data FuzzyQuery =

1004 FuzzyQuery { fuzzyQueryField :: FieldName

1005 , fuzzyQueryValue :: Text

1006 , fuzzyQueryPrefixLength :: PrefixLength

1007 , fuzzyQueryMaxExpansions :: MaxExpansions

1008 , fuzzyQueryFuzziness :: Fuzziness

1009 , fuzzyQueryBoost :: Maybe Boost

1010 } deriving (Eq, Show)

1011

1012data FuzzyLikeFieldQuery =

1013 FuzzyLikeFieldQuery

1014 { fuzzyLikeField :: FieldName

1015 -- anaphora is good for the soul.

1016 , fuzzyLikeFieldText :: Text

1017 , fuzzyLikeFieldMaxQueryTerms :: MaxQueryTerms

1018 , fuzzyLikeFieldIgnoreTermFrequency :: IgnoreTermFrequency

1019 , fuzzyLikeFieldFuzziness :: Fuzziness

1020 , fuzzyLikeFieldPrefixLength :: PrefixLength

1021 , fuzzyLikeFieldBoost :: Boost

1022 , fuzzyLikeFieldAnalyzer :: Maybe Analyzer

1023 } deriving (Eq, Show)

1024

1025data FuzzyLikeThisQuery =

1026 FuzzyLikeThisQuery

1027 { fuzzyLikeFields :: [FieldName]

1028 , fuzzyLikeText :: Text

1029 , fuzzyLikeMaxQueryTerms :: MaxQueryTerms

1030 , fuzzyLikeIgnoreTermFrequency :: IgnoreTermFrequency

1031 , fuzzyLikeFuzziness :: Fuzziness

1032 , fuzzyLikePrefixLength :: PrefixLength

1033 , fuzzyLikeBoost :: Boost

1034 , fuzzyLikeAnalyzer :: Maybe Analyzer

1035 } deriving (Eq, Show)

1036

1037data FilteredQuery =

1038 FilteredQuery

1039 { filteredQuery :: Query

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

1041

1042data DisMaxQuery =

1043 DisMaxQuery { disMaxQueries :: [Query]

1044 -- default 0.0

1045 , disMaxTiebreaker :: Tiebreaker

1046 , disMaxBoost :: Maybe Boost

1047 } deriving (Eq, Show)

1048

1049data MatchQuery =

1050 MatchQuery { matchQueryField :: FieldName

1051 , matchQueryQueryString :: QueryString

1052 , matchQueryOperator :: BooleanOperator

1053 , matchQueryZeroTerms :: ZeroTermsQuery

1054 , matchQueryCutoffFrequency :: Maybe CutoffFrequency

1055 , matchQueryMatchType :: Maybe MatchQueryType

1056 , matchQueryAnalyzer :: Maybe Analyzer

1057 , matchQueryMaxExpansions :: Maybe MaxExpansions

1058 , matchQueryLenient :: Maybe Lenient

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

1060

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

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

1063-}

1064mkMatchQuery :: FieldName -> QueryString -> MatchQuery

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

1066

1067data MatchQueryType =

1068 MatchPhrase

1069 | MatchPhrasePrefix deriving (Eq, Show)

1070

1071data MultiMatchQuery =

1072 MultiMatchQuery { multiMatchQueryFields :: [FieldName]

1073 , multiMatchQueryString :: QueryString

1074 , multiMatchQueryOperator :: BooleanOperator

1075 , multiMatchQueryZeroTerms :: ZeroTermsQuery

1076 , multiMatchQueryTiebreaker :: Maybe Tiebreaker

1077 , multiMatchQueryType :: Maybe MultiMatchQueryType

1078 , multiMatchQueryCutoffFrequency :: Maybe CutoffFrequency

1079 , multiMatchQueryAnalyzer :: Maybe Analyzer

1080 , multiMatchQueryMaxExpansions :: Maybe MaxExpansions

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

1082

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

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

1085 make a 'MultiMatchQuery'.

1086-}

1087

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

1089mkMultiMatchQuery matchFields query =

1090 MultiMatchQuery matchFields query

1091 Or ZeroTermsNone Nothing Nothing Nothing Nothing Nothing Nothing

1092

1093data MultiMatchQueryType =

1094 MultiMatchBestFields

1095 | MultiMatchMostFields

1096 | MultiMatchCrossFields

1097 | MultiMatchPhrase

1098 | MultiMatchPhrasePrefix deriving (Eq, Show)

1099

1100data BoolQuery =

1101 BoolQuery { boolQueryMustMatch :: [Query]

1102 , boolQueryMustNotMatch :: [Query]

1103 , boolQueryShouldMatch :: [Query]

1104 , boolQueryMinimumShouldMatch :: Maybe MinimumMatch

1105 , boolQueryBoost :: Maybe Boost

1106 , boolQueryDisableCoord :: Maybe DisableCoord

1107 } deriving (Eq, Show)

1108

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

1110mkBoolQuery must mustNot should =

1111 BoolQuery must mustNot should Nothing Nothing Nothing

1112

1113data BoostingQuery =

1114 BoostingQuery { positiveQuery :: Query

1115 , negativeQuery :: Query

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

1117

1118data CommonTermsQuery =

1119 CommonTermsQuery { commonField :: FieldName

1120 , commonQuery :: QueryString

1121 , commonCutoffFrequency :: CutoffFrequency

1122 , commonLowFreqOperator :: BooleanOperator

1123 , commonHighFreqOperator :: BooleanOperator

1124 , commonMinimumShouldMatch :: Maybe CommonMinimumMatch

1125 , commonBoost :: Maybe Boost

1126 , commonAnalyzer :: Maybe Analyzer

1127 , commonDisableCoord :: Maybe DisableCoord

1128 } deriving (Eq, Show)

1129

1130data CommonMinimumMatch =

1131 CommonMinimumMatchHighLow MinimumMatchHighLow

1132 | CommonMinimumMatch MinimumMatch

1133 deriving (Eq, Show)

1134

1135data MinimumMatchHighLow =

1136 MinimumMatchHighLow { lowFreq :: MinimumMatch

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

1138

1139data Filter = AndFilter [Filter] Cache

1140 | OrFilter [Filter] Cache

1141 | NotFilter Filter Cache

1142 | IdentityFilter

1143 | BoolFilter BoolMatch

1144 | ExistsFilter FieldName -- always cached

1145 | GeoBoundingBoxFilter GeoBoundingBoxConstraint

1146 | GeoDistanceFilter GeoPoint Distance DistanceType OptimizeBbox Cache

1147 | GeoDistanceRangeFilter GeoPoint DistanceRange

1148 | GeoPolygonFilter FieldName [LatLon]

1149 | IdsFilter MappingName [DocId]

1150 | LimitFilter Int

1151 | MissingFilter FieldName Existence NullValue

1152 | PrefixFilter FieldName PrefixValue Cache

1153 | QueryFilter Query Cache

1154 | RangeFilter FieldName RangeValue RangeExecution Cache

1155 | RegexpFilter FieldName Regexp RegexpFlags CacheName Cache CacheKey

1156 | TermFilter Term Cache

1157 deriving (Eq, Show)

1158

1159data ZeroTermsQuery = ZeroTermsNone

1160 | ZeroTermsAll deriving (Eq, Show)

1161

1162data RangeExecution = RangeExecutionIndex

1163 | RangeExecutionFielddata deriving (Eq, Show)

1164

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

1166

1167data RegexpFlags = AllRegexpFlags

1168 | NoRegexpFlags

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

1170

1171data RegexpFlag = AnyString

1172 | Automaton

1173 | Complement

1174 | Empty

1175 | Intersection

1176 | Interval deriving (Eq, Show)

1177

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

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

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

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

1182

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

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

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

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

1187

1188data RangeValue = RangeDateLte LessThanEqD

1189 | RangeDateLt LessThanD

1190 | RangeDateGte GreaterThanEqD

1191 | RangeDateGt GreaterThanD

1192 | RangeDateGtLt GreaterThanD LessThanD

1193 | RangeDateGteLte GreaterThanEqD LessThanEqD

1194 | RangeDateGteLt GreaterThanEqD LessThanD

1195 | RangeDateGtLte GreaterThanD LessThanEqD

1196 | RangeDoubleLte LessThanEq

1197 | RangeDoubleLt LessThan

1198 | RangeDoubleGte GreaterThanEq

1199 | RangeDoubleGt GreaterThan

1200 | RangeDoubleGtLt GreaterThan LessThan

1201 | RangeDoubleGteLte GreaterThanEq LessThanEq

1202 | RangeDoubleGteLt GreaterThanEq LessThan

1203 | RangeDoubleGtLte GreaterThan LessThanEq

1204 deriving (Eq, Show)

1205

1206rangeValueToPair :: RangeValue -> [Pair]

1207rangeValueToPair rv = case rv of

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1224

1225data Term = Term { termField :: Text

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

1227

1228data BoolMatch = MustMatch Term Cache

1229 | MustNotMatch Term Cache

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

1231

1232-- "memory" or "indexed"

1233data GeoFilterType = GeoFilterMemory

1234 | GeoFilterIndexed deriving (Eq, Show)

1235

1236data LatLon = LatLon { lat :: Double

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

1238

1239data GeoBoundingBox =

1240 GeoBoundingBox { topLeft :: LatLon

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

1242

1243data GeoBoundingBoxConstraint =

1244 GeoBoundingBoxConstraint { geoBBField :: FieldName

1245 , constraintBox :: GeoBoundingBox

1246 , bbConstraintcache :: Cache

1247 , geoType :: GeoFilterType

1248 } deriving (Eq, Show)

1249

1250data GeoPoint =

1251 GeoPoint { geoField :: FieldName

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

1253

1254data DistanceUnit = Miles

1255 | Yards

1256 | Feet

1257 | Inches

1258 | Kilometers

1259 | Meters

1260 | Centimeters

1261 | Millimeters

1262 | NauticalMiles deriving (Eq, Show)

1263

1264data DistanceType = Arc

1265 | SloppyArc -- doesn't exist <1.0

1266 | Plane deriving (Eq, Show)

1267

1268data OptimizeBbox = OptimizeGeoFilterType GeoFilterType

1269 | NoOptimizeBbox deriving (Eq, Show)

1270

1271data Distance =

1272 Distance { coefficient :: Double

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

1274

1275data DistanceRange =

1276 DistanceRange { distanceFrom :: Distance

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

1278

1279data SearchResult a =

1280 SearchResult { took :: Int

1281 , timedOut :: Bool

1282 , shards :: ShardResult

1283 , searchHits :: SearchHits a

1284 , aggregations :: Maybe AggregationResults

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

1286

1287type ScrollId = Text -- Fixme: Newtype

1288

1289type Score = Maybe Double

1290

1291data SearchHits a =

1292 SearchHits { hitsTotal :: Int

1293 , maxScore :: Score

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

1295

1296

1297instance Monoid (SearchHits a) where

1298 mempty = SearchHits 0 Nothing mempty

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

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

1301

1302

1303data Hit a =

1304 Hit { hitIndex :: IndexName

1305 , hitType :: MappingName

1306 , hitDocId :: DocId

1307 , hitScore :: Score

1308 , hitSource :: a

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

1310

1311data ShardResult =

1312 ShardResult { shardTotal :: Int

1313 , shardsSuccessful :: Int

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

1315

1316type HitHighlight = M.Map Text [Text]

1317

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

1319showText = T.pack . show

1320

1321type Aggregations = M.Map Text Aggregation

1322

1323emptyAggregations :: Aggregations

1324emptyAggregations = M.empty

1325

1326mkAggregations :: Text -> Aggregation -> Aggregations

1327mkAggregations name aggregation = M.insert name aggregation emptyAggregations

1328

1329data TermOrder = TermOrder{ termSortField :: Text

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

1331

1332data TermInclusion = TermInclusion Text

1333 | TermPattern Text Text deriving (Eq, Show)

1334

1335data CollectionMode = BreadthFirst

1336 | DepthFirst deriving (Eq, Show)

1337

1338data ExecutionHint = Ordinals

1339 | GlobalOrdinals

1340 | GlobalOrdinalsHash

1341 | GlobalOrdinalsLowCardinality

1342 | Map deriving (Eq, Show)

1343

1344data TimeInterval = Weeks

1345 | Days

1346 | Hours

1347 | Minutes

1348 | Seconds deriving (Eq)

1349

1350data Interval = Year

1351 | Quarter

1352 | Month

1353 | Week

1354 | Day

1355 | Hour

1356 | Minute

1357 | Second

1358 | FractionalInterval Float TimeInterval deriving (Eq, Show)

1359

1360data Aggregation = TermsAgg TermsAggregation

1361 | DateHistogramAgg DateHistogramAggregation

1362 | ValueCountAgg ValueCountAggregation

1363 | FilterAgg FilterAggregation deriving (Eq, Show)

1364

1365

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

1367 , termInclude :: Maybe TermInclusion

1368 , termExclude :: Maybe TermInclusion

1369 , termOrder :: Maybe TermOrder

1370 , termMinDocCount :: Maybe Int

1371 , termSize :: Maybe Int

1372 , termShardSize :: Maybe Int

1373 , termCollectMode :: Maybe CollectionMode

1374 , termExecutionHint :: Maybe ExecutionHint

1375 , termAggs :: Maybe Aggregations

1376 } deriving (Eq, Show)

1377

1378data DateHistogramAggregation = DateHistogramAggregation { dateField :: FieldName

1379 , dateInterval :: Interval

1380 , dateFormat :: Maybe Text

1381 -- pre and post deprecated in 1.5

1382 , datePreZone :: Maybe Text

1383 , datePostZone :: Maybe Text

1384 , datePreOffset :: Maybe Text

1385 , datePostOffset :: Maybe Text

1386 , dateAggs :: Maybe Aggregations

1387 } deriving (Eq, Show)

1388

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

1390data ValueCountAggregation = FieldValueCount FieldName

1391 | ScriptValueCount Script deriving (Eq, Show)

1392

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

1394data FilterAggregation = FilterAggregation { faFilter :: Filter

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

1396

1397mkTermsAggregation :: Text -> TermsAggregation