@@ -21,9 +21,19 @@ Endorsements
2121Version compatibility
2222---------------------
2323
24−Elasticsearch \>=1.0 && \<2.0 is recommended. Bloodhound mostly works with 0.9.x, but I don't recommend it if you expect everything to work. As of Bloodhound 0.3 all \>=1.0 && \<2.0 versions of Elasticsearch work. Some (or even most?) features will work with versions \>=2.0, but it is not officially supported yet.
24+As of version 0.13.0.0, Bloodhound has 2 separate module trees for
25+ElasticSearch versions 1 and 5. Import the module that is appropriate
26+for your use case. If you would like to add support for another major
27+version, open a ticket expressing your intend and follow the pattern
28+used for other versions. We weighed the idea of sharing code between
29+versions but it just got too messy, especially considering the
30+instability of the ElasticSearch API. We switched to a model which
31+would allow the persons responsible for a particular protocol version
32+to maintain that version while avoiding conflict with other versions.
33+
34+See our [TravisCI](https://travis-ci.org/bitemyapp/bloodhound) for a
35+listing of ElasticSearch version we test against.
2536
26−Current versions we test against are 1.2.4, 1.3.6, 1.4.1, 1.5.2, 1.6.0, and 1.7.2. We also check that GHC 7.6 and 7.8 both build and pass tests. See our [TravisCI](https://travis-ci.org/bitemyapp/bloodhound) to learn more.
2737
2838Stability
2939---------
@@ -41,7 +51,7 @@ Steps to run the tests locally:
4151 3. In your local Bloodhound directory, run `stack setup && stack build`
4252 4. Start the desired version of ElasticSearch at `localhost:9200`, which should be the default.
4353 5. Run `stack test` in your local Bloodhound directory.
44− 6. The unit tests will pass if you re-execute `stack test`, but some of the doctests might fail due to existing data in ElasticSearch. If you want to start with a clean slate, stop your ElasticSearch instance, delete the `data/` folder in the ElasticSearch installation, restart ElasticSearch, and re-run `stack test`.
54+ 6. The unit tests will pass if you re-execute `stack test`. If you want to start with a clean slate, stop your ElasticSearch instance, delete the `data/` folder in the ElasticSearch installation, restart ElasticSearch, and re-run `stack test`.
4555
4656
4757Hackage page and Haddock documentation
@@ -57,837 +67,7 @@ It's not using Bloodhound, but if you need an introduction to or overview of Ela
5767Examples
5868========
5969
60−Index Operations
61−----------------
62−
63−### Create Index
64−
65−``` {.haskell}
66−
67−-- Formatted for use in ghci, so there are "let"s in front of the decls.
68−
69−-- if you see :{ and :}, they're so you can copy-paste
70−-- the multi-line examples into your ghci REPL.
71−
72−:set -XDeriveGeneric
73−:set -XOverloadedStrings
74−:{
75−import Control.Applicative
76−import Database.Bloodhound
77−import Data.Aeson
78−import Data.Either (Either(..))
79−import Data.Maybe (fromJust)
80−import Data.Time.Calendar (Day(..))
81−import Data.Time.Clock (secondsToDiffTime, UTCTime(..))
82−import Data.Text (Text)
83−import GHC.Generics (Generic)
84−import Network.HTTP.Client
85−import qualified Network.HTTP.Types.Status as NHTS
86−
87−-- no trailing slashes in servers, library handles building the path.
88−let testServer = (Server "http://localhost:9200")
89−let testIndex = IndexName "twitter"
90−let testMapping = MappingName "tweet"
91−let withBH' = withBH defaultManagerSettings testServer
92−
93−-- defaultIndexSettings is exported by Database.Bloodhound as well
94−let defaultIndexSettings = IndexSettings (ShardCount 3) (ReplicaCount 2)
95−
96−-- createIndex returns MonadBH m => m Reply. You can use withBH for
97−-- one-off commands or you can use runBH to group together commands
98−-- and to pass in your own HTTP manager for pipelining.
99−
100−-- response :: Reply, Reply is a synonym for Network.HTTP.Conduit.Response
101−response <- withBH' $ createIndex defaultIndexSettings testIndex
102−:}
103−
104−```
105−
106−### Delete Index
107−
108−#### Code
109−
110−``` {.haskell}
111−
112−-- response :: Reply
113−response <- withBH' $ deleteIndex testIndex
114−
115−```
116−
117−#### Example Response
118−
119−``` {.haskell}
120−
121−-- print response if it was a success
122−Response {responseStatus = Status {statusCode = 200, statusMessage = "OK"}
123− , responseVersion = HTTP/1.1
124− , responseHeaders = [("Content-Type", "application/json; charset=UTF-8")
125− , ("Content-Length", "21")]
126− , responseBody = "{\"acknowledged\":true}"
127− , responseCookieJar = CJ {expose = []}
128− , responseClose' = ResponseClose}
129−
130−-- if the index to be deleted didn't exist anyway
131−Response {responseStatus = Status {statusCode = 404, statusMessage = "Not Found"}
132− , responseVersion = HTTP/1.1
133− , responseHeaders = [("Content-Type", "application/json; charset=UTF-8")
134− , ("Content-Length","65")]
135− , responseBody = "{\"error\":\"IndexMissingException[[twitter] missing]\",\"status\":404}"
136− , responseCookieJar = CJ {expose = []}
137− , responseClose' = ResponseClose}
138−
139−```
140−
141−### Refresh Index
142−
143−#### Note, you **have** to do this if you expect to read what you just wrote
144−
145−``` {.haskell}
146−
147−resp <- withBH' $ refreshIndex testIndex
148−
149−```
150−
151−#### Example Response
152−
153−``` {.haskell}
154−
155−-- print resp on success
156−Response {responseStatus = Status {statusCode = 200, statusMessage = "OK"}
157− , responseVersion = HTTP/1.1
158− , responseHeaders = [("Content-Type", "application/json; charset=UTF-8")
159− , ("Content-Length","50")]
160− , responseBody = "{\"_shards\":{\"total\":10,\"successful\":5,\"failed\":0}}"
161− , responseCookieJar = CJ {expose = []}
162− , responseClose' = ResponseClose}
163−
164−```
165−
166−Mapping Operations
167−------------------
168−
169−### Create Mapping
170−
171−``` {.haskell}
172−
173−-- don't forget imports and the like at the top.
174−
175−data TweetMapping = TweetMapping deriving (Eq, Show)
176−
177−-- I know writing the JSON manually sucks.
178−-- I don't have a proper data type for Mappings yet.
179−-- Let me know if this is something you need.
180−
181−:{
182−instance ToJSON TweetMapping where
183− toJSON TweetMapping =
184− object ["properties" .=
185− object ["location" .=
186− object ["type" .= ("geo_point" :: Text)]]]
187−:}
188−
189−resp <- withBH' $ putMapping testIndex testMapping TweetMapping
190−
191−```
192−
193−### Delete Mapping
194−
195−``` {.haskell}
196−
197−resp <- withBH' $ deleteMapping testIndex testMapping
198−
199−```
200−
201−Document Operations
202−-------------------
203−
204−### Indexing Documents
205−
206−``` {.haskell}
207−
208−-- don't forget the imports and derive generic setting for ghci
209−-- at the beginning of the examples.
210−
211−:{
212−data Location = Location { lat :: Double
213− , lon :: Double } deriving (Eq, Generic, Show)
214−
215−data Tweet = Tweet { user :: Text
216− , postDate :: UTCTime
217− , message :: Text
218− , age :: Int
219− , location :: Location } deriving (Eq, Generic, Show)
220−
221−exampleTweet = Tweet { user = "bitemyapp"
222− , postDate = UTCTime
223− (ModifiedJulianDay 55000)
224− (secondsToDiffTime 10)
225− , message = "Use haskell!"
226− , age = 10000
227− , location = Location 40.12 (-71.34) }
228−
229−-- automagic (generic) derivation of instances because we're lazy.
230−instance ToJSON Tweet
231−instance FromJSON Tweet
232−instance ToJSON Location
233−instance FromJSON Location
234−:}
235−
236−-- Should be able to toJSON and encode the data structures like this:
237−-- λ> toJSON $ Location 10.0 10.0
238−-- Object fromList [("lat",Number 10.0),("lon",Number 10.0)]
239−-- λ> encode $ Location 10.0 10.0
240−-- "{\"lat\":10,\"lon\":10}"
241−
242−resp <- withBH' $ indexDocument testIndex testMapping defaultIndexDocumentSettings exampleTweet (DocId "1")
243−
244−```
245−
246−#### Example Response
247−
248−``` {.haskell}
249−
250−Response {responseStatus =
251− Status {statusCode = 200, statusMessage = "OK"}
252− , responseVersion = HTTP/1.1, responseHeaders =
253− [("Content-Type","application/json; charset=UTF-8"),
254− ("Content-Length","75")]
255− , responseBody = "{\"_index\":\"twitter\",\"_type\":\"tweet\",\"_id\":\"1\",\"_version\":2,\"created\":false}"
256− , responseCookieJar = CJ {expose = []}, responseClose' = ResponseClose}
257−
258−```
259−
260−### Deleting Documents
261−
262−``` {.haskell}
263−
264−resp <- withBH' $ deleteDocument testIndex testMapping (DocId "1")
265−
266−```
267−
268−### Getting Documents
269−
270−``` {.haskell}
271−
272−-- n.b., you'll need the earlier imports. responseBody is from http-conduit
273−
274−resp <- withBH' $ getDocument testIndex testMapping (DocId "1")
275−
276−-- responseBody :: Response body -> body
277−let body = responseBody resp
278−
279−-- you have two options, you use decode and just get Maybe (EsResult Tweet)
280−-- or you can use eitherDecode and get Either String (EsResult Tweet)
281−
282−let maybeResult = decode body :: Maybe (EsResult Tweet)
283−-- the explicit typing is so Aeson knows how to parse the JSON.
284−
285−-- use either if you want to know why something failed to parse.
286−-- (string errors, sadly)
287−let eitherResult = eitherDecode body :: Either String (EsResult Tweet)
288−
289−-- print eitherResult should look like:
290−Right (EsResult {_index = "twitter"
291− , _type = "tweet"
292− , _id = "1"
293− , foundResult = Just (EsResultFound { _version = 2
294− , _source = Tweet {user = "bitemyapp"
295− , postDate = 2009-06-18 00:00:10 UTC
296− , message = "Use haskell!"
297− , age = 10000
298− , location = Location {lat = 40.12, lon = -71.34}}})})
299−
300−-- _source in EsResultFound is parametric, we dispatch the type by passing in what we expect (Tweet) as a parameter to EsResult.
301−
302−-- use the _source record accessor to get at your document
303−fmap (fmap _source . foundResult) eitherResult
304−Right (Just (Tweet {user = "bitemyapp"
305− , postDate = 2009-06-18 00:00:10 UTC
306− , message = "Use haskell!"
307− , age = 10000
308− , location = Location {lat = 40.12, lon = -71.34}}))
309−
310−```
311−
312−Bulk Operations
313−---------------
314−
315−### Bulk create, index
316−
317−``` {.haskell}
318−
319−-- don't forget the imports and derive generic setting for ghci
320−-- at the beginning of the examples.
321−
322−:{
323−-- Using the earlier Tweet datatype and exampleTweet data
324−
325−-- just changing up the data a bit.
326−let bulkTest = exampleTweet { user = "blah" }
327−let bulkTestTwo = exampleTweet { message = "woohoo!" }
328−
329−-- create only bulk operation
330−-- BulkCreate :: IndexName -> MappingName -> DocId -> Value -> BulkOperation
331−let firstOp = BulkCreate testIndex
332− testMapping (DocId "3") (toJSON bulkTest)
333−
334−-- index operation "create or update"
335−let sndOp = BulkIndex testIndex
336− testMapping (DocId "4") (toJSON bulkTestTwo)
337−
338−-- Some explanation, the final "Value" type that BulkIndex,
339−-- BulkCreate, and BulkUpdate accept is the actual document
340−-- data that your operation applies to. BulkDelete doesn't
341−-- take a value because it's just deleting whatever DocId
342−-- you pass.
343−
344−-- list of bulk operations
345−let stream = [firstDoc, secondDoc]
346−
347−-- Fire off the actual bulk request
348−-- bulk :: Vector BulkOperation -> IO Reply
349−resp <- withBH' $ bulk stream
350−:}
351−
352−```
353−
354−### Encoding individual bulk API operations
355−
356−``` {.haskell}
357−-- the following functions are exported in Bloodhound so
358−-- you can build up bulk operations yourself
359−encodeBulkOperations :: V.Vector BulkOperation -> L.ByteString
360−encodeBulkOperation :: BulkOperation -> L.ByteString
361−
362−-- How to use the above:
363−data BulkTest = BulkTest { name :: Text } deriving (Eq, Generic, Show)
364−instance FromJSON BulkTest
365−instance ToJSON BulkTest
366−
367−_ <- insertData
368−let firstTest = BulkTest "blah"
369−let secondTest = BulkTest "bloo"
370−let firstDoc = BulkIndex testIndex
371− testMapping (DocId "2") (toJSON firstTest)
372−let secondDoc = BulkCreate testIndex
373− testMapping (DocId "3") (toJSON secondTest)
374−let stream = V.fromList [firstDoc, secondDoc] :: V.Vector BulkOperation
375−
376−-- to encode yourself
377−let firstDocEncoded = encode firstDoc :: L.ByteString
378−
379−-- to encode a vector of bulk operations
380−let encodedOperations = encodeBulkOperations stream
381−
382−-- to insert into a particular server
383−-- bulk :: V.Vector BulkOperation -> IO Reply
384−_ <- withBH' $ bulk streamp
385−
386−```
387−
388−Search
389−------
390−
391−### Querying
392−
393−#### Term Query
394−
395−``` {.haskell}
396−
397−-- exported by the Client module, just defaults some stuff.
398−-- mkSearch :: Maybe Query -> Maybe Filter -> Search
399−-- mkSearch query filter = Search query filter Nothing False (From 0) (Size 10) Nothing
400−
401−let query = TermQuery (Term "user" "bitemyapp") Nothing
402−
403−-- AND'ing identity filter with itself and then tacking it onto a query
404−-- search should be a null-operation. I include it for the sake of example.
405−-- <||> (or/plus) should make it into a search that returns everything.
406−
407−let filter = IdentityFilter <&&> IdentityFilter
408−
409−-- constructing the search object the searchByIndex function dispatches on.
410−let search = mkSearch (Just query) (Just filter)
411−
412−-- you can also searchByType and specify the mapping name.
413−reply <- withBH' $ searchByIndex testIndex search
414−
415−let result = eitherDecode (responseBody reply) :: Either String (SearchResult Tweet)
416−
417−λ> fmap (hits . searchHits) result
418−Right [Hit {hitIndex = IndexName "twitter"
419− , hitType = MappingName "tweet"
420− , hitDocId = DocId "1"
421− , hitScore = 0.30685282
422− , hitSource = Tweet {user = "bitemyapp"
423− , postDate = 2009-06-18 00:00:10 UTC
424− , message = "Use haskell!"
425− , age = 10000
426− , location = Location {lat = 40.12, lon = -71.34}}}]
427−
428−```
429−
430−#### Match Query
431−
432−``` {.haskell}
433−
434−let query = QueryMatchQuery $ mkMatchQuery (FieldName "user") (QueryString "bitemyapp")
435−let search = mkSearch (Just query) Nothing
436−
437−```
438−
439−#### Multi-Match Query
440−
441−``` {.haskell}
442−
443−let fields = [FieldName "user", FieldName "message"]
444−let query = QueryMultiMatchQuery $ mkMultiMatchQuery fields (QueryString "bitemyapp")
445−let search = mkSearch (Just query) Nothing
446−
447−```
448−
449−#### Bool Query
450−
451−``` {.haskell}
452−
453−let innerQuery = QueryMatchQuery $
454− mkMatchQuery (FieldName "user") (QueryString "bitemyapp")
455−let query = QueryBoolQuery $
456− mkBoolQuery [innerQuery] [] []
457−let search = mkSearch (Just query) Nothing
458−
459−```
460−
461−#### Boosting Query
462−
463−``` {.haskell}
464−
465−let posQuery = QueryMatchQuery $
466− mkMatchQuery (FieldName "user") (QueryString "bitemyapp")
467−let negQuery = QueryMatchQuery $
468− mkMatchQuery (FieldName "user") (QueryString "notmyapp")
469−let query = QueryBoostingQuery $
470− BoostingQuery posQuery negQuery (Boost 0.2)
471−
472−```
473−
474−#### Rest of the query/filter types
475−
476−Just follow the pattern you've seen here and check the Hackage API documentation.
477−
478−### Sorting
479−
480−``` {.haskell}
481−
482−let sortSpec = DefaultSortSpec $ mkSort (FieldName "age") Ascending
483−
484−-- mkSort is a shortcut function that takes a FieldName and a SortOrder
485−-- to generate a vanilla DefaultSort.
486−-- checkt the DefaultSort type for the full list of customizable options.
487−
488−-- From and size are integers for pagination.
489−
490−-- When sorting on a field, scores are not computed. By setting TrackSortScores to true, scores will still be computed and tracked.
491−
492−-- type Sort = [SortSpec]
493−-- type TrackSortScores = Bool
494−-- type From = Int
495−-- type Size = Int
496−
497−-- Search takes Maybe Query
498−-- -> Maybe Filter
499−-- -> Maybe Sort
500−-- -> TrackSortScores
501−-- -> From -> Size
502−-- -> Maybe [FieldName]
503−
504−-- just add more sortspecs to the list if you want tie-breakers.
505−let search = Search Nothing (Just IdentityFilter) (Just [sortSpec]) False (From 0) (Size 10) Nothing
506−
507−```
508−
509−### Field selection
510−
511−If you only want certain fields from the source document returned, you can
512−set the "fields" field of the Search record.
513−
514−``` {.haskell}
515−
516−let search' = mkSearch (Just (MatchAllQuery Nothing)) Nothing
517− search = search' { fields = Just [FieldName "updated"] }
518−
519−```
520−
521−### Filtering
522−
523−#### And, Not, and Or filters
524−
525−Filters form a monoid and seminearring.
526−
527−``` {.haskell}
528−
529−instance Monoid Filter where
530− mempty = IdentityFilter
531− mappend a b = AndFilter [a, b] defaultCache
532−
533−instance Seminearring Filter where
534− a <||> b = OrFilter [a, b] defaultCache
535−
536−-- AndFilter and OrFilter take [Filter] as an argument.
537−
538−-- This will return anything, because IdentityFilter returns everything
539−OrFilter [IdentityFilter, someOtherFilter] False
540−
541−-- This will return exactly what someOtherFilter returns
542−AndFilter [IdentityFilter, someOtherFilter] False
543−
544−-- Thanks to the seminearring and monoid, the above can be expressed as:
545−
546−-- "and"
547−IdentityFilter <&&> someOtherFilter
548−
549−-- "or"
550−IdentityFilter <||> someOtherFilter
551−
552−-- Also there is a NotFilter, it only accepts a single filter, not a list.
553−
554−NotFilter someOtherFilter False
555−
556−```
557−
558−#### Identity Filter
559−
560−``` {.haskell}
561−
562−-- And'ing two Identity
563−let queryFilter = IdentityFilter <&&> IdentityFilter
564−
565−let search = mkSearch Nothing (Just queryFilter)
566−
567−reply <- withBH' $ searchByType testIndex testMapping search
568−
569−```
570−
571−#### Boolean Filter
572−
573−Similar to boolean queries.
574−
575−``` {.haskell}
576−
577−-- Will return only items whose "user" field contains the term "bitemyapp"
578−let queryFilter = BoolFilter (MustMatch (Term "user" "bitemyapp") False)
579−
580−-- Will return only items whose "user" field does not contain the term "bitemyapp"
581−let queryFilter = BoolFilter (MustNotMatch (Term "user" "bitemyapp") False)
582−
583−-- The clause (query) should appear in the matching document.
584−-- In a boolean query with no must clauses, one or more should
585−-- clauses must match a document. The minimum number of should
586−-- clauses to match can be set using the minimum_should_match parameter.
587−let queryFilter = BoolFilter (ShouldMatch [(Term "user" "bitemyapp")] False)
588−
589−```
590−
591−#### Exists Filter
592−
593−``` {.haskell}
594−
595−-- Will filter for documents that have the field "user"
596−let existsFilter = ExistsFilter (FieldName "user")
597−
598−```
599−
600−#### Geo BoundingBox Filter
601−
602−``` {.haskell}
603−
604−-- topLeft and bottomRight
605−let box = GeoBoundingBox (LatLon 40.73 (-74.1)) (LatLon 40.10 (-71.12))
606−
607−let constraint = GeoBoundingBoxConstraint (FieldName "tweet.location") box False GeoFilterMemory
608−
609−```
610−
611−#### Geo Distance Filter
612−
613−``` {.haskell}
614−
615−let geoPoint = GeoPoint (FieldName "tweet.location") (LatLon 40.12 (-71.34))
616−
617−-- coefficient and units
618−let distance = Distance 10.0 Miles
619−
620−-- GeoFilterType or NoOptimizeBbox
621−let optimizeBbox = OptimizeGeoFilterType GeoFilterMemory
622−
623−-- SloppyArc is the usual/default optimization in Elasticsearch today
624−-- but pre-1.0 versions will need to pick Arc or Plane.
625−
626−let geoFilter = GeoDistanceFilter geoPoint distance SloppyArc optimizeBbox False
627−
628−```
629−
630−#### Geo Distance Range Filter
631−
632−Think of a donut and you won't be far off.
633−
634−``` {.haskell}
635−
636−let geoPoint = GeoPoint (FieldName "tweet.location") (LatLon 40.12 (-71.34))
637−
638−let distanceRange = DistanceRange (Distance 0.0 Miles) (Distance 10.0 Miles)
639−
640−let geoFilter = GeoDistanceRangeFilter geoPoint distanceRange
641−
642−```
643−
644−#### Geo Polygon Filter
645−
646−``` {.haskell}
647−
648−-- I think I drew a square here.
649−let points = [LatLon 40.0 (-70.00),
650− LatLon 40.0 (-72.00),
651− LatLon 41.0 (-70.00),
652− LatLon 41.0 (-72.00)]
653−
654−let geoFilter = GeoPolygonFilter (FieldName "tweet.location") points
655−
656−```
657−
658−#### Document IDs filter
659−
660−``` {.haskell}
661−
662−-- takes a mapping name and a list of DocIds
663−IdsFilter (MappingName "tweet") [DocId "1"]
664−
665−```
666−
667−#### Range Filter
668−
669−``` {.haskell}
670−
671−-- RangeFilter :: FieldName
672−-- -> RangeValue
673−-- -> RangeExecution
674−-- -> Cache -> Filter
675−
676−let filter = RangeFilter (FieldName "age")
677− (RangeGtLt (GreaterThan 1000.0) (LessThan 100000.0))
678− RangeExecutionIndex False
679−
680−```
681−
682−``` {.haskell}
683−
684−let filter = RangeFilter (FieldName "age")
685− (RangeLte (LessThanEq 100000.0))
686− RangeExecutionIndex False
687−
688−```
689−
690−##### Date Ranges
691−
692−Date ranges are expressed in UTCTime. Date ranges use the same range bound constructors as numerics, except that they end in "D".
693−
694−Note that compatibility with ES is tested only down to seconds.
695−
696−``` {.haskell}
697−
698−let filter = RangeFilter (FieldName "postDate")
699− (RangeDateGtLte
700− (GreaterThanD (UTCTime
701− (ModifiedJulianDay 55000)
702− (secondsToDiffTime 9)))
703− (LessThanEqD (UTCTime
704− (ModifiedJulianDay 55000)
705− (secondsToDiffTime 11))))
706− RangeExecutionIndex False
707−```
708−
709−#### Regexp Filter
710−
711−``` {.haskell}
712−
713−-- RegexpFilter
714−-- :: FieldName
715−-- -> Regexp
716−-- -> RegexpFlags
717−-- -> CacheName
718−-- -> Cache
719−-- -> CacheKey
720−-- -> Filter
721−let filter = RegexpFilter (FieldName "user") (Regexp "bite.*app")
722− AllRegexpFlags (CacheName "test") False (CacheKey "key")
723−
724−-- n.b.
725−-- data RegexpFlags = AllRegexpFlags
726−-- | NoRegexpFlags
727−-- | SomeRegexpFlags (NonEmpty RegexpFlag) deriving (Eq, Show)
728−
729−-- data RegexpFlag = AnyString
730−-- | Automaton
731−-- | Complement
732−-- | Empty
733−-- | Intersection
734−-- | Interval deriving (Eq, Show)
735−
736−```
737−
738−### Aggregations
739−
740−#### Adding aggregations to search
741−
742−Aggregations can now be added to search queries, or made on their own.
743−
744−``` {.haskell}
745−type Aggregations = M.Map Text Aggregation
746−data Aggregation
747− = TermsAgg TermsAggregation
748− | DateHistogramAgg DateHistogramAggregation
749−```
750−
751−For convenience, \`\`\`mkAggregations\`\`\` exists, that will create an \`\`\`Aggregations\`\`\` with the aggregation provided.
752−
753−For example:
754−
755−``` {.haskell}
756− let a = mkAggregations "users" $ TermsAgg $ mkTermsAggregation "user"
757− let search = mkAggregateSearch Nothing a
758−```
759−
760−Aggregations can be added to an existing search, using the \`\`\`aggBody\`\`\` field
761−
762−``` {.haskell}
763− let search = mkSearch (Just (MatchAllQuery Nothing)) Nothing
764− let search' = search {aggBody = Just a}
765−```
766−
767−Since the \`\`\`Aggregations\`\`\` structure is just a Map Text Aggregation, M.insert can be used to add additional aggregations.
768−
769−``` {.haskell}
770− let a' = M.insert "age" (TermsAgg $ mkTermsAggregation "age") a
771−```
772−
773−#### Extracting aggregations from results
774−
775−Aggregations are part of the reply structure of every search, in the
776−form of `Maybe AggregationResults`
777−
778−``` {.haskell}
779−-- Lift decode and response body to be in the IO monad.
780−let decode' = liftM decode
781−let responseBody' = liftM responseBody
782−let reply = withBH' $ searchByIndex testIndex search
783−let response = decode' $ responseBody' reply :: IO (Maybe (SearchResult Tweet))
784−
785−-- Now that we have our response, we can extract our terms aggregation result -- which is a list of buckets.
786−
787−let terms = do { response' <- response; return $ response' >>= aggregations >>= toTerms "users" }
788−terms
789−Just (Bucket {buckets = [TermsResult {termKey = "bitemyapp", termsDocCount = 1, termsAggs = Nothing}]})
790−```
791−
792−Note that bucket aggregation results, such as the TermsResult is a member of the type class `BucketAggregation`:
793−
794−``` {.haskell}
795−class BucketAggregation a where
796− key :: a -> Text
797− docCount :: a -> Int
798− aggs :: a -> Maybe AggregationResults
799−```
800−
801−You can use the `aggs` function to get any nested results, if there
802−were any. For example, if there were a nested terms aggregation keyed
803−to "age" in a TermsResult named `termresult` , you would call `aggs
804−termresult >>= toTerms "age"`
805−
806−#### Terms Aggregation
807−
808−``` {.haskell}
809−data TermsAggregation
810− = TermsAggregation {term :: Either Text Text,
811− termInclude :: Maybe TermInclusion,
812− termExclude :: Maybe TermInclusion,
813− termOrder :: Maybe TermOrder,
814− termMinDocCount :: Maybe Int,
815− termSize :: Maybe Int,
816− termShardSize :: Maybe Int,
817− termCollectMode :: Maybe CollectionMode,
818− termExecutionHint :: Maybe ExecutionHint,
819− termAggs :: Maybe Aggregations}
820−```
821−
822−Term Aggregations have two factory functions, `mkTermsAggregation`, and
823−`mkTermsScriptAggregation`, and can be used as follows:
824−
825−``` {.haskell}
826−let ta = TermsAgg $ mkTermsAggregation "user"
827−```
828−
829−There are of course other options that can be added to a Terms Aggregation, such as the collection mode:
830−
831−``` {.haskell}
832−let ta = mkTermsAggregation "user"
833−let ta' = ta { termCollectMode = Just BreadthFirst }
834−let ta'' = TermsAgg ta'
835−```
836−
837−For more documentation on how the Terms Aggregation works, see <https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-bucket-terms-aggregation.html>
838−
839−#### Date Histogram Aggregation
840−
841−``` {.haskell}
842−data DateHistogramAggregation
843− = DateHistogramAggregation {dateField :: FieldName,
844− dateInterval :: Interval,
845− dateFormat :: Maybe Text,
846− datePreZone :: Maybe Text,
847− datePostZone :: Maybe Text,
848− datePreOffset :: Maybe Text,
849− datePostOffset :: Maybe Text,
850− dateAggs :: Maybe Aggregations}
851−```
852−
853−The Date Histogram Aggregation works much the same as the Terms Aggregation.
854−
855−Relevant functions include `mkDateHistogram`, and `toDateHistogram`
856−
857−``` {.haskell}
858−let dh = DateHistogramAgg (mkDateHistogram (FieldName "postDate") Minute)
859−```
860−
861−Date histograms also accept a `FractionalInterval`:
862−
863−``` {.haskell}
864−FractionalInterval :: Float -> TimeInterval -> Interval
865−-- TimeInterval is the following:
866−data TimeInterval = Weeks | Days | Hours | Minutes | Seconds
867−```
868−
869−It can be used as follows:
870−
871−``` {.haskell}
872−let dh = DateHistogramAgg (mkDateHistogram (FieldName "postDate") (FractionalInterval 1.5 Minutes))
873−```
874−
875−The `DateHistogramResult` is defined as:
876−
877−``` {.haskell}
878−data DateHistogramResult
879− = DateHistogramResult {dateKey :: Int,
880− dateKeyStr :: Maybe Text,
881− dateDocCount :: Int,
882− dateHistogramAggs :: Maybe AggregationResults}
883−```
884−
885−It is an instance of `BucketAggregation`, and can have nested aggregations in each bucket.
886−
887−Buckets can be extracted from an `AggregationResult` using
888−`toDateHistogram name`
889−
890−For more information on the Date Histogram Aggregation, see: <https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-bucket-datehistogram-aggregation.html>
70+See the [examples](htts://github.com/bitemyapp/bloodhound/tree/master/examples) directory for example code.
89171
89272
89373Contributors