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

git.iko.soy/typeable/bloodhound

on update-index-settings help sign in

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

2665 lines 103 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 , UpdatableIndexSetting(..)

60 , IndexSettingsSummary(..)

61 , AllocationPolicy(..)

62 , ReplicaBounds(..)

63 , Bytes(..)

64 , FSType(..)

65 , InitialShardCount(..)

66 , NodeAttrFilter(..)

67 , NodeAttrName(..)

68 , CompoundFormat(..)

69 , IndexTemplate(..)

70 , Server(..)

71 , Reply

72 , EsResult(..)

73 , EsResultFound(..)

74 , EsError(..)

75 , DocVersion

76 , ExternalDocVersion(..)

77 , VersionControl(..)

78 , DocumentParent(..)

79 , IndexDocumentSettings(..)

80 , Query(..)

81 , Search(..)

82 , SearchType(..)

83 , SearchResult(..)

84 , ScrollId

85 , SearchHits(..)

86 , TrackSortScores

87 , From(..)

88 , Size(..)

89 , Source(..)

90 , PatternOrPatterns(..)

91 , Include(..)

92 , Exclude(..)

93 , Pattern(..)

94 , ShardResult(..)

95 , Hit(..)

96 , Filter(..)

97 , Seminearring(..)

98 , BoolMatch(..)

99 , Term(..)

100 , GeoPoint(..)

101 , GeoBoundingBoxConstraint(..)

102 , GeoBoundingBox(..)

103 , GeoFilterType(..)

104 , Distance(..)

105 , DistanceUnit(..)

106 , DistanceType(..)

107 , DistanceRange(..)

108 , OptimizeBbox(..)

109 , LatLon(..)

110 , RangeValue(..)

111 , RangeExecution(..)

112 , LessThan(..)

113 , LessThanEq(..)

114 , GreaterThan(..)

115 , GreaterThanEq(..)

116 , LessThanD(..)

117 , LessThanEqD(..)

118 , GreaterThanD(..)

119 , GreaterThanEqD(..)

120 , Regexp(..)

121 , RegexpFlags(..)

122 , RegexpFlag(..)

123 , FieldName(..)

124 , Script(..)

125 , IndexName(..)

126 , TemplateName(..)

127 , TemplatePattern(..)

128 , MappingName(..)

129 , DocId(..)

130 , CacheName(..)

131 , CacheKey(..)

132 , BulkOperation(..)

133 , ReplicaCount(..)

134 , ShardCount(..)

135 , Sort

136 , SortMode(..)

137 , SortOrder(..)

138 , SortSpec(..)

139 , DefaultSort(..)

140 , Missing(..)

141 , OpenCloseIndex(..)

142 , Method

143 , Boost(..)

144 , MatchQuery(..)

145 , MultiMatchQuery(..)

146 , BoolQuery(..)

147 , BoostingQuery(..)

148 , CommonTermsQuery(..)

149 , DisMaxQuery(..)

150 , FilteredQuery(..)

151 , FuzzyLikeThisQuery(..)

152 , FuzzyLikeFieldQuery(..)

153 , FuzzyQuery(..)

154 , HasChildQuery(..)

155 , HasParentQuery(..)

156 , IndicesQuery(..)

157 , MoreLikeThisQuery(..)

158 , MoreLikeThisFieldQuery(..)

159 , NestedQuery(..)

160 , PrefixQuery(..)

161 , QueryStringQuery(..)

162 , SimpleQueryStringQuery(..)

163 , RangeQuery(..)

164 , RegexpQuery(..)

165 , QueryString(..)

166 , BooleanOperator(..)

167 , ZeroTermsQuery(..)

168 , CutoffFrequency(..)

169 , Analyzer(..)

170 , MaxExpansions(..)

171 , Lenient(..)

172 , MatchQueryType(..)

173 , MultiMatchQueryType(..)

174 , Tiebreaker(..)

175 , MinimumMatch(..)

176 , DisableCoord(..)

177 , CommonMinimumMatch(..)

178 , MinimumMatchHighLow(..)

179 , PrefixLength(..)

180 , Fuzziness(..)

181 , IgnoreTermFrequency(..)

182 , MaxQueryTerms(..)

183 , ScoreType(..)

184 , Score

185 , Cache

186 , TypeName(..)

187 , BoostTerms(..)

188 , MaxWordLength(..)

189 , MinWordLength(..)

190 , MaxDocFrequency(..)

191 , MinDocFrequency(..)

192 , PhraseSlop(..)

193 , StopWord(..)

194 , QueryPath(..)

195 , MinimumTermFrequency(..)

196 , PercentMatch(..)

197 , FieldDefinition(..)

198 , MappingField(..)

199 , Mapping(..)

200 , AllowLeadingWildcard(..)

201 , LowercaseExpanded(..)

202 , GeneratePhraseQueries(..)

203 , Locale(..)

204 , AnalyzeWildcard(..)

205 , EnablePositionIncrements(..)

206 , SimpleQueryFlag(..)

207 , FieldOrFields(..)

208 , Monoid(..)

209 , ToJSON(..)

210 , Interval(..)

211 , TimeInterval(..)

212 , ExecutionHint(..)

213 , CollectionMode(..)

214 , TermOrder(..)

215 , TermInclusion(..)

216

217 , Aggregation(..)

218 , Aggregations

219 , AggregationResults

220 , Bucket(..)

221 , BucketAggregation(..)

222 , TermsAggregation(..)

223 , ValueCountAggregation(..)

224 , FilterAggregation(..)

225 , DateHistogramAggregation(..)

226

227 , Highlights(..)

228 , FieldHighlight(..)

229 , HighlightSettings(..)

230 , PlainHighlight(..)

231 , PostingsHighlight(..)

232 , FastVectorHighlight(..)

233 , CommonHighlight(..)

234 , NonPostings(..)

235 , HighlightEncoder(..)

236 , HighlightTag(..)

237 , HitHighlight

238

239 , TermsResult(..)

240 , DateHistogramResult(..)

241 ) where

242

243import Control.Applicative

244import Control.Monad.Catch

245import Control.Monad.Except

246import Control.Monad.Reader

247import Control.Monad.State

248import Control.Monad.Writer

249import Data.Aeson

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

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

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

253import Data.List (foldl', nub)

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

255import qualified Data.Map.Strict as M

256import Data.Maybe

257import Data.Text (Text)

258import qualified Data.Text as T

259import Data.Time.Clock (UTCTime, NominalDiffTime)

260import qualified Data.Vector as V

261import GHC.Enum

262import GHC.Generics (Generic)

263import Network.HTTP.Client

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

265

266import Database.Bloodhound.Types.Class

267

268-- $setup

269-- >>> :set -XOverloadedStrings

270-- >>> import Database.Bloodhound

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

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

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

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

275

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

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

278

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

280 pipelined according to the provided HTTP connection manager.

281-}

282data BHEnv = BHEnv { bhServer :: Server

283 , bhManager :: Manager

284 }

285

286{-| All API calls to Elasticsearch operate within

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

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

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

290-}

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

292 getBHEnv :: m BHEnv

293

294newtype BH m a = BH {

295 unBH :: ReaderT BHEnv m a

296 } deriving ( Functor

297 , Applicative

298 , Monad

299 , MonadIO

300 , MonadState s

301 , MonadWriter w

302 , MonadError e

303 , Alternative

304 , MonadPlus

305 , MonadFix

306 , MonadThrow

307 , MonadCatch

308 , MonadMask)

309

310instance MonadTrans BH where

311 lift = BH . lift

312

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

314 ask = lift ask

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

316 local f (m r)

317

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

319 getBHEnv = BH getBHEnv

320

321

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

323 getBHEnv = ask

324

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

326runBH e f = runReaderT (unBH f) e

327

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

329data Version = Version { number :: Text

330 , build_hash :: Text

331 , build_timestamp :: UTCTime

332 , build_snapshot :: Bool

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

334

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

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

337

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

339-}

340

341data Status = Status { ok :: Maybe Bool

342 , status :: Int

343 , name :: Text

344 , version :: Version

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

346

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

348 an Elasticsearch Index.

349

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

351-}

352

353data IndexSettings =

354 IndexSettings { indexShards :: ShardCount

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

356

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

358defaultIndexSettings :: IndexSettings

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

360

361{-| 'UpdatableIndexSetting' are settings which may be updated after an index is created.

362

363 <https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-update-settings.html>

364-}

365data UpdatableIndexSetting = NumberOfReplicas ReplicaCount

366 -- ^ The number of replicas each shard has.

367 | AutoExpandReplicas ReplicaBounds

368 | BlocksReadOnly Bool

369 -- ^ Set to True to have the index read only. False to allow writes and metadata changes.

370 | BlocksRead Bool

371 -- ^ Set to True to disable read operations against the index.

372 | BlocksWrite Bool

373 -- ^ Set to True to disable write operations against the index.

374 | BlocksMetaData Bool

375 -- ^ Set to True to disable metadata operations against the index.

376 | RefreshInterval NominalDiffTime

377 -- ^ The async refresh interval of a shard

378 | IndexConcurrency Int

379 | FailOnMergeFailure Bool

380 | TranslogFlushThresholdOps Int

381 -- ^ When to flush on operations.

382 | TranslogFlushThresholdSize Bytes

383 -- ^ When to flush based on translog (bytes) size.

384 | TranslogFlushThresholdPeriod NominalDiffTime

385 -- ^ When to flush based on a period of not flushing.

386 | TranslogDisableFlush Bool

387 -- ^ Disables flushing. Note, should be set for a short interval and then enabled.

388 | CacheFilterMaxSize (Maybe Bytes)

389 -- ^ The maximum size of filter cache (per segment in shard).

390 | CacheFilterExpire (Maybe NominalDiffTime)

391 -- ^ The expire after access time for filter cache.

392 | GatewaySnapshotInterval NominalDiffTime

393 -- ^ The gateway snapshot interval (only applies to shared gateways).

394 | RoutingAllocationInclude (NonEmpty NodeAttrFilter)

395 -- ^ A node matching any rule will be allowed to host shards from the index.

396 | RoutingAllocationExclude (NonEmpty NodeAttrFilter)

397 -- ^ A node matching any rule will NOT be allowed to host shards from the index.

398 | RoutingAllocationRequire (NonEmpty NodeAttrFilter)

399 -- ^ Only nodes matching all rules will be allowed to host shards from the index.

400 | RoutingAllocationEnable AllocationPolicy

401 -- ^ Enables shard allocation for a specific index.

402 | RoutingAllocationShardsPerNode ShardCount

403 -- ^ Controls the total number of shards (replicas and primaries) allowed to be allocated on a single node.

404 | RecoveryInitialShards InitialShardCount

405 -- ^ When using local gateway a particular shard is recovered only if there can be allocated quorum shards in the cluster.

406 | GCDeletes NominalDiffTime

407 | TTLDisablePurge Bool

408 -- ^ Disables temporarily the purge of expired docs.

409 | TranslogFSType FSType

410 | IndexCompoundFormat CompoundFormat

411 | IndexCompoundOnFlush Bool

412 | WarmerEnabled Bool

413 deriving (Eq, Show)

414

415data AllocationPolicy = AllocAll

416 -- ^ Allows shard allocation for all shards.

417 | AllocPrimaries

418 -- ^ Allows shard allocation only for primary shards.

419 | AllocNewPrimaries

420 -- ^ Allows shard allocation only for primary shards for new indices.

421 | AllocNone

422 -- ^ No shard allocation is allowed

423 deriving (Eq, Show)

424

425data ReplicaBounds = ReplicasBounded Int Int

426 | ReplicasLowerBounded Int

427 | ReplicasUnbounded

428 deriving (Eq, Show)

429

430newtype Bytes = Bytes Int deriving (Eq, Show, Ord, ToJSON)

431

432data FSType = FSSimple

433 | FSBuffered deriving (Eq, Show, Ord)

434

435data InitialShardCount = QuorumShards

436 | QuorumMinus1Shards

437 | FullShards

438 | FullMinus1Shards

439 | ExplicitShards Int

440 deriving (Eq, Show)

441

442data NodeAttrFilter = NodeAttrFilter { nodeAttrFilterName :: NodeAttrName

443 , nodeAttrFilterValues :: NonEmpty Text}

444 deriving (Eq, Show)

445

446newtype NodeAttrName = NodeAttrName Text deriving (Eq, Show)

447

448data CompoundFormat = CompoundFileFormat Bool

449 | MergeSegmentVsTotalIndex Double

450 -- ^ percentage between 0 and 1 where 0 is false, 1 is true

451 deriving (Eq, Show)

452

453newtype NominalDiffTimeJSON = NominalDiffTimeJSON NominalDiffTime

454

455data IndexSettingsSummary = IndexSettingsSummary { sSummaryShardCount :: ShardCount

456 , sSummaryUpdateable :: [UpdatableIndexSetting]}

457 deriving (Eq, Show)

458

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

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

461type Method = NHTM.Method

462

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

464

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

466-}

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

468

469data FieldType = GeoPointType

470 | GeoShapeType

471 | FloatType

472 | IntegerType

473 | LongType

474 | ShortType

475 | ByteType deriving (Eq, Show)

476

477data FieldDefinition =

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

479

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

481 applied to new indices created. The templates include both

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

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

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

485

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

487-}

488data IndexTemplate =

489 IndexTemplate { templatePattern :: TemplatePattern

490 , templateSettings :: Maybe IndexSettings

491 , templateMappings :: [Value]

492 }

493

494data MappingField =

495 MappingField { mappingFieldName :: FieldName

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

497

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

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

500

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

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

503 and keeping different kinds of documents separated if possible.

504-}

505data Mapping = Mapping { typeName :: TypeName

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

507

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

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

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

511

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

513-}

514data BulkOperation =

515 BulkIndex IndexName MappingName DocId Value

516 | BulkCreate IndexName MappingName DocId Value

517 | BulkDelete IndexName MappingName DocId

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

519

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

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

522-}

523data EsResult a = EsResult { _index :: Text

524 , _type :: Text

525 , _id :: Text

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

527

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

529 'EsResult' when the document was successfully found.

530-}

531data EsResultFound a = EsResultFound { _version :: DocVersion

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

533

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

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

536 try parsing this.

537-}

538data EsError = EsError { errorStatus :: Int

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

540

541

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

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

544-}

545newtype DocVersion = DocVersion {

546 docVersionNumber :: Int

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

548

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

550mkDocVersion :: Int -> Maybe DocVersion

551mkDocVersion i

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

553 Just $ DocVersion i

554 | otherwise = Nothing

555

556

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

558own version numbers instead of ones from ES.

559-}

560newtype ExternalDocVersion = ExternalDocVersion DocVersion

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

562

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

564optimistic concurrency control.

565-}

566data VersionControl = NoVersionControl

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

568 | InternalVersion DocVersion

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

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

571 -- as the one specified. Only applicable to

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

573 -- a search result.

574 | ExternalGT ExternalDocVersion

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

576 -- the document if the version is strictly higher

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

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

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

580 -- increment this number, meaning there is some

581 -- global, external ordering of updates.

582 | ExternalGTE ExternalDocVersion

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

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

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

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

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

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

589 -- result in data loss.

590 | ForceVersion ExternalDocVersion

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

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

593 -- typically used for correcting errors. Use with

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

595 deriving (Show, Eq, Ord)

596

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

598-}

599newtype DocumentParent = DocumentParent DocId

600 deriving (Eq, Show)

601

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

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

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

605-}

606data IndexDocumentSettings =

607 IndexDocumentSettings { idsVersionControl :: VersionControl

608 , idsParent :: Maybe DocumentParent

609 } deriving (Eq, Show)

610

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

612-}

613defaultIndexDocumentSettings :: IndexDocumentSettings

614defaultIndexDocumentSettings = IndexDocumentSettings NoVersionControl Nothing

615

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

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

618-}

619type Sort = [SortSpec]

620

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

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

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

624 sort specification.

625

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

627-}

628data SortSpec = DefaultSortSpec DefaultSort

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

630

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

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

633 common parameters.

634

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

636-}

637data DefaultSort =

638 DefaultSort { sortFieldName :: FieldName

639 , sortOrder :: SortOrder

640 -- default False

641 , ignoreUnmapped :: Bool

642 , sortMode :: Maybe SortMode

643 , missingSort :: Maybe Missing

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

645

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

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

648

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

650-}

651data SortOrder = Ascending

652 | Descending deriving (Eq, Show)

653

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

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

656

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

658-}

659data Missing = LastMissing

660 | FirstMissing

661 | CustomMissing Text deriving (Eq, Show)

662

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

664

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

666-}

667data SortMode = SortMin

668 | SortMax

669 | SortSum

670 | SortAvg deriving (Eq, Show)

671

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

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

674-}

675mkSort :: FieldName -> SortOrder -> DefaultSort

676mkSort fieldName sOrder = DefaultSort fieldName sOrder False Nothing Nothing Nothing

677

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

679 'Query's cannot be cached.

680-}

681type Cache = Bool -- caching on/off

682defaultCache :: Cache

683defaultCache = False

684

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

686-}

687type PrefixValue = Text

688

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

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

691-}

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

693

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

695-}

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

697

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

699-}

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

701

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

703-}

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

705

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

707-}

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

709

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

711-}

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

713

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

715-}

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

717

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

719 the data in the indices.

720-}

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

722

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

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

725 functions for poking at specific documents.

726-}

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

728

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

730-}

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

732

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

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

735-}

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

737

738

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

740complex ways of extracting a value from a document.

741-}

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

743

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

745 'CacheKey' keyed caching behavior.

746-}

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

748

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

750-}

751newtype CacheKey =

752 CacheKey Text deriving (Eq, Show)

753newtype Existence =

754 Existence Bool deriving (Eq, Show)

755newtype NullValue =

756 NullValue Bool deriving (Eq, Show)

757newtype CutoffFrequency =

758 CutoffFrequency Double deriving (Eq, Show, Generic)

759newtype Analyzer =

760 Analyzer Text deriving (Eq, Show, Generic)

761newtype MaxExpansions =

762 MaxExpansions Int deriving (Eq, Show, Generic)

763

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

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

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

767-}

768newtype Lenient =

769 Lenient Bool deriving (Eq, Show, Generic)

770newtype Tiebreaker =

771 Tiebreaker Double deriving (Eq, Show, Generic)

772newtype Boost =

773 Boost Double deriving (Eq, Show, Generic)

774newtype BoostTerms =

775 BoostTerms Double deriving (Eq, Show, Generic)

776

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

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

779 combination of both.

780-}

781newtype MinimumMatch =

782 MinimumMatch Int deriving (Eq, Show, Generic)

783newtype MinimumMatchText =

784 MinimumMatchText Text deriving (Eq, Show)

785newtype DisableCoord =

786 DisableCoord Bool deriving (Eq, Show, Generic)

787newtype IgnoreTermFrequency =

788 IgnoreTermFrequency Bool deriving (Eq, Show, Generic)

789newtype MinimumTermFrequency =

790 MinimumTermFrequency Int deriving (Eq, Show, Generic)

791newtype MaxQueryTerms =

792 MaxQueryTerms Int deriving (Eq, Show, Generic)

793newtype Fuzziness =

794 Fuzziness Double deriving (Eq, Show, Generic)

795

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

797newtype PrefixLength =

798 PrefixLength Int deriving (Eq, Show, Generic)

799newtype TypeName =

800 TypeName Text deriving (Eq, Show, Generic)

801newtype PercentMatch =

802 PercentMatch Double deriving (Eq, Show, Generic)

803newtype StopWord =

804 StopWord Text deriving (Eq, Show, Generic)

805newtype QueryPath =

806 QueryPath Text deriving (Eq, Show, Generic)

807

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

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

810 they match. Leading wildcards can be disabled by setting

811 'AllowLeadingWildcard' to false. -}

812newtype AllowLeadingWildcard =

813 AllowLeadingWildcard Bool deriving (Eq, Show, Generic)

814newtype LowercaseExpanded =

815 LowercaseExpanded Bool deriving (Eq, Show, Generic)

816newtype EnablePositionIncrements =

817 EnablePositionIncrements Bool deriving (Eq, Show, Generic)

818

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

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

821-}

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

823

824{-| 'GeneratePhraseQueries' defaults to false.

825-}

826newtype GeneratePhraseQueries =

827 GeneratePhraseQueries Bool deriving (Eq, Show, Generic)

828

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

830-}

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

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

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

834

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

836 phrase matches. Default is 0.

837-}

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

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

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

841

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

843-}

844unpackId :: DocId -> Text

845unpackId (DocId docId) = docId

846

847type TrackSortScores = Bool

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

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

850

851data Search = Search { queryBody :: Maybe Query

852 , filterBody :: Maybe Filter

853 , sortBody :: Maybe Sort

854 , aggBody :: Maybe Aggregations

855 , highlight :: Maybe Highlights

856 -- default False

857 , trackSortScores :: TrackSortScores

858 , from :: From

859 , size :: Size

860 , searchType :: SearchType

861 , fields :: Maybe [FieldName]

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

863

864data SearchType = SearchTypeQueryThenFetch

865 | SearchTypeDfsQueryThenFetch

866 | SearchTypeCount

867 | SearchTypeScan

868 | SearchTypeQueryAndFetch

869 | SearchTypeDfsQueryAndFetch

870 deriving (Eq, Show)

871

872data Source =

873 NoSource

874 | SourcePatterns PatternOrPatterns

875 | SourceIncludeExclude Include Exclude

876 deriving (Show, Eq)

877

878data PatternOrPatterns = PopPattern Pattern

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

880

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

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

883

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

885

886data Highlights = Highlights { globalsettings :: Maybe HighlightSettings

887 , highlightFields :: [FieldHighlight]

888 } deriving (Show, Eq)

889

890data FieldHighlight = FieldHighlight FieldName (Maybe HighlightSettings)

891 deriving (Show, Eq)

892

893

894data HighlightSettings = Plain PlainHighlight

895 | Postings PostingsHighlight

896 | FastVector FastVectorHighlight

897 deriving (Show, Eq)

898data PlainHighlight =

899 PlainHighlight { plainCommon :: Maybe CommonHighlight

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

901

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

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

904

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

906data FastVectorHighlight =

907 FastVectorHighlight { fvCommon :: Maybe CommonHighlight

908 , fvNonPostSettings :: Maybe NonPostings

909 , boundaryChars :: Maybe Text

910 , boundaryMaxScan :: Maybe Int

911 , fragmentOffset :: Maybe Int

912 , matchedFields :: [Text]

913 , phraseLimit :: Maybe Int

914 } deriving (Show, Eq)

915

916data CommonHighlight =

917 CommonHighlight { order :: Maybe Text

918 , forceSource :: Maybe Bool

919 , tag :: Maybe HighlightTag

920 , encoder :: Maybe HighlightEncoder

921 , noMatchSize :: Maybe Int

922 , highlightQuery :: Maybe Query

923 , requireFieldMatch :: Maybe Bool

924 } deriving (Show, Eq)

925

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

927data NonPostings =

928 NonPostings { fragmentSize :: Maybe Int

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

930

931data HighlightEncoder = DefaultEncoder

932 | HTMLEncoder

933 deriving (Show, Eq)

934

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

936data HighlightTag = TagSchema Text

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

938 deriving (Show, Eq)

939

940

941data Query =

942 TermQuery Term (Maybe Boost)

943 | TermsQuery (NonEmpty Term)

944 | QueryMatchQuery MatchQuery

945 | QueryMultiMatchQuery MultiMatchQuery

946 | QueryBoolQuery BoolQuery

947 | QueryBoostingQuery BoostingQuery

948 | QueryCommonTermsQuery CommonTermsQuery

949 | ConstantScoreFilter Filter Boost

950 | ConstantScoreQuery Query Boost

951 | QueryDisMaxQuery DisMaxQuery

952 | QueryFilteredQuery FilteredQuery

953 | QueryFuzzyLikeThisQuery FuzzyLikeThisQuery

954 | QueryFuzzyLikeFieldQuery FuzzyLikeFieldQuery

955 | QueryFuzzyQuery FuzzyQuery

956 | QueryHasChildQuery HasChildQuery

957 | QueryHasParentQuery HasParentQuery

958 | IdsQuery MappingName [DocId]

959 | QueryIndicesQuery IndicesQuery

960 | MatchAllQuery (Maybe Boost)

961 | QueryMoreLikeThisQuery MoreLikeThisQuery

962 | QueryMoreLikeThisFieldQuery MoreLikeThisFieldQuery

963 | QueryNestedQuery NestedQuery

964 | QueryPrefixQuery PrefixQuery

965 | QueryQueryStringQuery QueryStringQuery

966 | QuerySimpleQueryStringQuery SimpleQueryStringQuery

967 | QueryRangeQuery RangeQuery

968 | QueryRegexpQuery RegexpQuery

969 deriving (Eq, Show)

970

971data RegexpQuery =

972 RegexpQuery { regexpQueryField :: FieldName

973 , regexpQuery :: Regexp

974 , regexpQueryFlags :: RegexpFlags

975 , regexpQueryBoost :: Maybe Boost

976 } deriving (Eq, Show)

977

978data RangeQuery =

979 RangeQuery { rangeQueryField :: FieldName

980 , rangeQueryRange :: RangeValue

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

982

983mkRangeQuery :: FieldName -> RangeValue -> RangeQuery

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

985

986data SimpleQueryStringQuery =

987 SimpleQueryStringQuery

988 { simpleQueryStringQuery :: QueryString

989 , simpleQueryStringField :: Maybe FieldOrFields

990 , simpleQueryStringOperator :: Maybe BooleanOperator

991 , simpleQueryStringAnalyzer :: Maybe Analyzer

992 , simpleQueryStringFlags :: Maybe [SimpleQueryFlag]

993 , simpleQueryStringLowercaseExpanded :: Maybe LowercaseExpanded

994 , simpleQueryStringLocale :: Maybe Locale

995 } deriving (Eq, Show)

996

997data SimpleQueryFlag =

998 SimpleQueryAll

999 | SimpleQueryNone

1000 | SimpleQueryAnd

1001 | SimpleQueryOr

1002 | SimpleQueryPrefix

1003 | SimpleQueryPhrase

1004 | SimpleQueryPrecedence

1005 | SimpleQueryEscape

1006 | SimpleQueryWhitespace

1007 | SimpleQueryFuzzy

1008 | SimpleQueryNear

1009 | SimpleQuerySlop deriving (Eq, Show)

1010

1011-- use_dis_max and tie_breaker when fields are plural?

1012data QueryStringQuery =

1013 QueryStringQuery

1014 { queryStringQuery :: QueryString

1015 , queryStringDefaultField :: Maybe FieldName

1016 , queryStringOperator :: Maybe BooleanOperator

1017 , queryStringAnalyzer :: Maybe Analyzer

1018 , queryStringAllowLeadingWildcard :: Maybe AllowLeadingWildcard

1019 , queryStringLowercaseExpanded :: Maybe LowercaseExpanded

1020 , queryStringEnablePositionIncrements :: Maybe EnablePositionIncrements

1021 , queryStringFuzzyMaxExpansions :: Maybe MaxExpansions

1022 , queryStringFuzziness :: Maybe Fuzziness

1023 , queryStringFuzzyPrefixLength :: Maybe PrefixLength

1024 , queryStringPhraseSlop :: Maybe PhraseSlop

1025 , queryStringBoost :: Maybe Boost

1026 , queryStringAnalyzeWildcard :: Maybe AnalyzeWildcard

1027 , queryStringGeneratePhraseQueries :: Maybe GeneratePhraseQueries

1028 , queryStringMinimumShouldMatch :: Maybe MinimumMatch

1029 , queryStringLenient :: Maybe Lenient

1030 , queryStringLocale :: Maybe Locale

1031 } deriving (Eq, Show)

1032

1033mkQueryStringQuery :: QueryString -> QueryStringQuery

1034mkQueryStringQuery qs =

1035 QueryStringQuery qs Nothing Nothing

1036 Nothing Nothing Nothing Nothing

1037 Nothing Nothing Nothing Nothing

1038 Nothing Nothing Nothing Nothing

1039 Nothing Nothing

1040

1041data FieldOrFields = FofField FieldName

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

1043

1044data PrefixQuery =

1045 PrefixQuery

1046 { prefixQueryField :: FieldName

1047 , prefixQueryPrefixValue :: Text

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

1049

1050data NestedQuery =

1051 NestedQuery

1052 { nestedQueryPath :: QueryPath

1053 , nestedQueryScoreType :: ScoreType

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

1055

1056data MoreLikeThisFieldQuery =

1057 MoreLikeThisFieldQuery

1058 { moreLikeThisFieldText :: Text

1059 , moreLikeThisFieldFields :: FieldName

1060 -- default 0.3 (30%)

1061 , moreLikeThisFieldPercentMatch :: Maybe PercentMatch

1062 , moreLikeThisFieldMinimumTermFreq :: Maybe MinimumTermFrequency

1063 , moreLikeThisFieldMaxQueryTerms :: Maybe MaxQueryTerms

1064 , moreLikeThisFieldStopWords :: Maybe [StopWord]

1065 , moreLikeThisFieldMinDocFrequency :: Maybe MinDocFrequency

1066 , moreLikeThisFieldMaxDocFrequency :: Maybe MaxDocFrequency

1067 , moreLikeThisFieldMinWordLength :: Maybe MinWordLength

1068 , moreLikeThisFieldMaxWordLength :: Maybe MaxWordLength

1069 , moreLikeThisFieldBoostTerms :: Maybe BoostTerms

1070 , moreLikeThisFieldBoost :: Maybe Boost

1071 , moreLikeThisFieldAnalyzer :: Maybe Analyzer

1072 } deriving (Eq, Show)

1073

1074data MoreLikeThisQuery =

1075 MoreLikeThisQuery

1076 { moreLikeThisText :: Text

1077 , moreLikeThisFields :: Maybe [FieldName]

1078 -- default 0.3 (30%)

1079 , moreLikeThisPercentMatch :: Maybe PercentMatch

1080 , moreLikeThisMinimumTermFreq :: Maybe MinimumTermFrequency

1081 , moreLikeThisMaxQueryTerms :: Maybe MaxQueryTerms

1082 , moreLikeThisStopWords :: Maybe [StopWord]

1083 , moreLikeThisMinDocFrequency :: Maybe MinDocFrequency

1084 , moreLikeThisMaxDocFrequency :: Maybe MaxDocFrequency

1085 , moreLikeThisMinWordLength :: Maybe MinWordLength

1086 , moreLikeThisMaxWordLength :: Maybe MaxWordLength

1087 , moreLikeThisBoostTerms :: Maybe BoostTerms

1088 , moreLikeThisBoost :: Maybe Boost

1089 , moreLikeThisAnalyzer :: Maybe Analyzer

1090 } deriving (Eq, Show)

1091

1092data IndicesQuery =

1093 IndicesQuery

1094 { indicesQueryIndices :: [IndexName]

1095 , indicesQuery :: Query

1096 -- default "all"

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

1098

1099data HasParentQuery =

1100 HasParentQuery

1101 { hasParentQueryType :: TypeName

1102 , hasParentQuery :: Query

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

1104

1105data HasChildQuery =

1106 HasChildQuery

1107 { hasChildQueryType :: TypeName

1108 , hasChildQuery :: Query

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

1110

1111data ScoreType =

1112 ScoreTypeMax

1113 | ScoreTypeSum

1114 | ScoreTypeAvg

1115 | ScoreTypeNone deriving (Eq, Show)

1116

1117data FuzzyQuery =

1118 FuzzyQuery { fuzzyQueryField :: FieldName

1119 , fuzzyQueryValue :: Text

1120 , fuzzyQueryPrefixLength :: PrefixLength

1121 , fuzzyQueryMaxExpansions :: MaxExpansions

1122 , fuzzyQueryFuzziness :: Fuzziness

1123 , fuzzyQueryBoost :: Maybe Boost

1124 } deriving (Eq, Show)

1125

1126data FuzzyLikeFieldQuery =

1127 FuzzyLikeFieldQuery

1128 { fuzzyLikeField :: FieldName

1129 -- anaphora is good for the soul.

1130 , fuzzyLikeFieldText :: Text

1131 , fuzzyLikeFieldMaxQueryTerms :: MaxQueryTerms

1132 , fuzzyLikeFieldIgnoreTermFrequency :: IgnoreTermFrequency

1133 , fuzzyLikeFieldFuzziness :: Fuzziness

1134 , fuzzyLikeFieldPrefixLength :: PrefixLength

1135 , fuzzyLikeFieldBoost :: Boost

1136 , fuzzyLikeFieldAnalyzer :: Maybe Analyzer

1137 } deriving (Eq, Show)

1138

1139data FuzzyLikeThisQuery =

1140 FuzzyLikeThisQuery

1141 { fuzzyLikeFields :: [FieldName]

1142 , fuzzyLikeText :: Text

1143 , fuzzyLikeMaxQueryTerms :: MaxQueryTerms

1144 , fuzzyLikeIgnoreTermFrequency :: IgnoreTermFrequency

1145 , fuzzyLikeFuzziness :: Fuzziness

1146 , fuzzyLikePrefixLength :: PrefixLength

1147 , fuzzyLikeBoost :: Boost

1148 , fuzzyLikeAnalyzer :: Maybe Analyzer

1149 } deriving (Eq, Show)

1150

1151data FilteredQuery =

1152 FilteredQuery

1153 { filteredQuery :: Query

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

1155

1156data DisMaxQuery =

1157 DisMaxQuery { disMaxQueries :: [Query]

1158 -- default 0.0

1159 , disMaxTiebreaker :: Tiebreaker

1160 , disMaxBoost :: Maybe Boost

1161 } deriving (Eq, Show)

1162

1163data MatchQuery =

1164 MatchQuery { matchQueryField :: FieldName

1165 , matchQueryQueryString :: QueryString

1166 , matchQueryOperator :: BooleanOperator

1167 , matchQueryZeroTerms :: ZeroTermsQuery

1168 , matchQueryCutoffFrequency :: Maybe CutoffFrequency

1169 , matchQueryMatchType :: Maybe MatchQueryType

1170 , matchQueryAnalyzer :: Maybe Analyzer

1171 , matchQueryMaxExpansions :: Maybe MaxExpansions

1172 , matchQueryLenient :: Maybe Lenient

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

1174

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

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

1177-}

1178mkMatchQuery :: FieldName -> QueryString -> MatchQuery

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

1180

1181data MatchQueryType =

1182 MatchPhrase

1183 | MatchPhrasePrefix deriving (Eq, Show)

1184

1185data MultiMatchQuery =

1186 MultiMatchQuery { multiMatchQueryFields :: [FieldName]

1187 , multiMatchQueryString :: QueryString

1188 , multiMatchQueryOperator :: BooleanOperator

1189 , multiMatchQueryZeroTerms :: ZeroTermsQuery

1190 , multiMatchQueryTiebreaker :: Maybe Tiebreaker

1191 , multiMatchQueryType :: Maybe MultiMatchQueryType

1192 , multiMatchQueryCutoffFrequency :: Maybe CutoffFrequency

1193 , multiMatchQueryAnalyzer :: Maybe Analyzer

1194 , multiMatchQueryMaxExpansions :: Maybe MaxExpansions

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

1196

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

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

1199 make a 'MultiMatchQuery'.

1200-}

1201

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

1203mkMultiMatchQuery matchFields query =

1204 MultiMatchQuery matchFields query

1205 Or ZeroTermsNone Nothing Nothing Nothing Nothing Nothing Nothing

1206

1207data MultiMatchQueryType =

1208 MultiMatchBestFields

1209 | MultiMatchMostFields

1210 | MultiMatchCrossFields

1211 | MultiMatchPhrase

1212 | MultiMatchPhrasePrefix deriving (Eq, Show)

1213

1214data BoolQuery =

1215 BoolQuery { boolQueryMustMatch :: [Query]

1216 , boolQueryMustNotMatch :: [Query]

1217 , boolQueryShouldMatch :: [Query]

1218 , boolQueryMinimumShouldMatch :: Maybe MinimumMatch

1219 , boolQueryBoost :: Maybe Boost

1220 , boolQueryDisableCoord :: Maybe DisableCoord

1221 } deriving (Eq, Show)

1222

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

1224mkBoolQuery must mustNot should =

1225 BoolQuery must mustNot should Nothing Nothing Nothing

1226

1227data BoostingQuery =

1228 BoostingQuery { positiveQuery :: Query

1229 , negativeQuery :: Query

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

1231

1232data CommonTermsQuery =

1233 CommonTermsQuery { commonField :: FieldName

1234 , commonQuery :: QueryString

1235 , commonCutoffFrequency :: CutoffFrequency

1236 , commonLowFreqOperator :: BooleanOperator

1237 , commonHighFreqOperator :: BooleanOperator

1238 , commonMinimumShouldMatch :: Maybe CommonMinimumMatch

1239 , commonBoost :: Maybe Boost

1240 , commonAnalyzer :: Maybe Analyzer

1241 , commonDisableCoord :: Maybe DisableCoord

1242 } deriving (Eq, Show)

1243

1244data CommonMinimumMatch =

1245 CommonMinimumMatchHighLow MinimumMatchHighLow

1246 | CommonMinimumMatch MinimumMatch

1247 deriving (Eq, Show)

1248

1249data MinimumMatchHighLow =

1250 MinimumMatchHighLow { lowFreq :: MinimumMatch

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

1252

1253data Filter = AndFilter [Filter] Cache

1254 | OrFilter [Filter] Cache

1255 | NotFilter Filter Cache

1256 | IdentityFilter

1257 | BoolFilter BoolMatch

1258 | ExistsFilter FieldName -- always cached

1259 | GeoBoundingBoxFilter GeoBoundingBoxConstraint

1260 | GeoDistanceFilter GeoPoint Distance DistanceType OptimizeBbox Cache

1261 | GeoDistanceRangeFilter GeoPoint DistanceRange

1262 | GeoPolygonFilter FieldName [LatLon]

1263 | IdsFilter MappingName [DocId]

1264 | LimitFilter Int

1265 | MissingFilter FieldName Existence NullValue

1266 | PrefixFilter FieldName PrefixValue Cache

1267 | QueryFilter Query Cache

1268 | RangeFilter FieldName RangeValue RangeExecution Cache

1269 | RegexpFilter FieldName Regexp RegexpFlags CacheName Cache CacheKey

1270 | TermFilter Term Cache

1271 deriving (Eq, Show)

1272

1273data ZeroTermsQuery = ZeroTermsNone

1274 | ZeroTermsAll deriving (Eq, Show)

1275

1276data RangeExecution = RangeExecutionIndex

1277 | RangeExecutionFielddata deriving (Eq, Show)

1278

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

1280

1281data RegexpFlags = AllRegexpFlags

1282 | NoRegexpFlags

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

1284

1285data RegexpFlag = AnyString

1286 | Automaton

1287 | Complement

1288 | Empty

1289 | Intersection

1290 | Interval deriving (Eq, Show)

1291

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

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

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

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

1296

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

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

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

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

1301

1302data RangeValue = RangeDateLte LessThanEqD

1303 | RangeDateLt LessThanD

1304 | RangeDateGte GreaterThanEqD

1305 | RangeDateGt GreaterThanD

1306 | RangeDateGtLt GreaterThanD LessThanD

1307 | RangeDateGteLte GreaterThanEqD LessThanEqD

1308 | RangeDateGteLt GreaterThanEqD LessThanD

1309 | RangeDateGtLte GreaterThanD LessThanEqD

1310 | RangeDoubleLte LessThanEq

1311 | RangeDoubleLt LessThan

1312 | RangeDoubleGte GreaterThanEq

1313 | RangeDoubleGt GreaterThan

1314 | RangeDoubleGtLt GreaterThan LessThan

1315 | RangeDoubleGteLte GreaterThanEq LessThanEq

1316 | RangeDoubleGteLt GreaterThanEq LessThan

1317 | RangeDoubleGtLte GreaterThan LessThanEq

1318 deriving (Eq, Show)

1319

1320rangeValueToPair :: RangeValue -> [Pair]

1321rangeValueToPair rv = case rv of

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1338

1339data Term = Term { termField :: Text

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

1341

1342data BoolMatch = MustMatch Term Cache

1343 | MustNotMatch Term Cache

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

1345

1346-- "memory" or "indexed"

1347data GeoFilterType = GeoFilterMemory

1348 | GeoFilterIndexed deriving (Eq, Show)

1349

1350data LatLon = LatLon { lat :: Double

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

1352

1353data GeoBoundingBox =

1354 GeoBoundingBox { topLeft :: LatLon

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

1356

1357data GeoBoundingBoxConstraint =

1358 GeoBoundingBoxConstraint { geoBBField :: FieldName

1359 , constraintBox :: GeoBoundingBox

1360 , bbConstraintcache :: Cache

1361 , geoType :: GeoFilterType

1362 } deriving (Eq, Show)

1363

1364data GeoPoint =

1365 GeoPoint { geoField :: FieldName

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

1367

1368data DistanceUnit = Miles

1369 | Yards

1370 | Feet

1371 | Inches

1372 | Kilometers

1373 | Meters

1374 | Centimeters

1375 | Millimeters

1376 | NauticalMiles deriving (Eq, Show)

1377

1378data DistanceType = Arc

1379 | SloppyArc -- doesn't exist <1.0

1380 | Plane deriving (Eq, Show)

1381

1382data OptimizeBbox = OptimizeGeoFilterType GeoFilterType

1383 | NoOptimizeBbox deriving (Eq, Show)

1384

1385data Distance =

1386 Distance { coefficient :: Double

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

1388

1389data DistanceRange =

1390 DistanceRange { distanceFrom :: Distance

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

1392

1393data SearchResult a =

1394 SearchResult { took :: Int

1395 , timedOut :: Bool

1396 , shards :: ShardResult

1397 , searchHits :: SearchHits a

1398 , aggregations :: Maybe AggregationResults

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

1400

1401type ScrollId = Text -- Fixme: Newtype

1402

1403type Score = Maybe Double

1404

1405data SearchHits a =

1406 SearchHits { hitsTotal :: Int

1407 , maxScore :: Score

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

1409

1410

1411instance Monoid (SearchHits a) where

1412 mempty = SearchHits 0 Nothing mempty

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

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

1415

1416

1417data Hit a =

1418 Hit { hitIndex :: IndexName

1419 , hitType :: MappingName

1420 , hitDocId :: DocId

1421 , hitScore :: Score

1422 , hitSource :: Maybe a

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

1424

1425data ShardResult =

1426 ShardResult { shardTotal :: Int

1427 , shardsSuccessful :: Int

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

1429

1430type HitHighlight = M.Map Text [Text]

1431

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

1433showText = T.pack . show

1434

1435type Aggregations = M.Map Text Aggregation

1436

1437emptyAggregations :: Aggregations

1438emptyAggregations = M.empty

1439

1440mkAggregations :: Text -> Aggregation -> Aggregations

1441mkAggregations name aggregation = M.insert name aggregation emptyAggregations

1442

1443data TermOrder = TermOrder{ termSortField :: Text

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

1445

1446data TermInclusion = TermInclusion Text

1447 | TermPattern Text Text deriving (Eq, Show)

1448

1449data CollectionMode = BreadthFirst

1450 | DepthFirst deriving (Eq, Show)

1451

1452data ExecutionHint = Ordinals

1453 | GlobalOrdinals

1454 | GlobalOrdinalsHash

1455 | GlobalOrdinalsLowCardinality

1456 | Map deriving (Eq, Show)

1457

1458data TimeInterval = Weeks

1459 | Days

1460 | Hours

1461 | Minutes

1462 | Seconds deriving (Eq)

1463

1464data Interval = Year

1465 | Quarter

1466 | Month

1467 | Week

1468 | Day

1469 | Hour

1470 | Minute

1471 | Second

1472 | FractionalInterval Float TimeInterval deriving (Eq, Show)

1473

1474data Aggregation = TermsAgg TermsAggregation

1475 | DateHistogramAgg DateHistogramAggregation

1476 | ValueCountAgg ValueCountAggregation

1477 | FilterAgg FilterAggregation deriving (Eq, Show)

1478

1479

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

1481 , termInclude :: Maybe TermInclusion

1482 , termExclude :: Maybe TermInclusion

1483 , termOrder :: Maybe TermOrder

1484 , termMinDocCount :: Maybe Int

1485 , termSize :: Maybe Int

1486 , termShardSize :: Maybe Int

1487 , termCollectMode :: Maybe CollectionMode

1488 , termExecutionHint :: Maybe ExecutionHint

1489 , termAggs :: Maybe Aggregations

1490 } deriving (Eq, Show)

1491

1492data DateHistogramAggregation = DateHistogramAggregation { dateField :: FieldName

1493 , dateInterval :: Interval

1494 , dateFormat :: Maybe Text

1495 -- pre and post deprecated in 1.5

1496 , datePreZone :: Maybe Text

1497 , datePostZone :: Maybe Text

1498 , datePreOffset :: Maybe Text

1499 , datePostOffset :: Maybe Text

1500 , dateAggs :: Maybe Aggregations

1501 } deriving (Eq, Show)

1502

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

1504data ValueCountAggregation = FieldValueCount FieldName

1505 | ScriptValueCount Script deriving (Eq, Show)

1506

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

1508data FilterAggregation = FilterAggregation { faFilter :: Filter

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

1510

1511mkTermsAggregation :: Text -> TermsAggregation