{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
module Database.Bloodhound.Internal.Query
( module X,
module Database.Bloodhound.Internal.Query,
)
where
import Bloodhound.Import
import qualified Data.Aeson.KeyMap as X
import qualified Data.HashMap.Strict as HM
import qualified Data.Text as T
import Database.Bloodhound.Common.Script as X
import Database.Bloodhound.Internal.Newtypes
import GHC.Generics
data Query
= TermQuery Term (Maybe Boost)
| TermsQuery Key (NonEmpty Text)
| QueryMatchQuery MatchQuery
| QueryMultiMatchQuery MultiMatchQuery
| QueryBoolQuery BoolQuery
| QueryBoostingQuery BoostingQuery
| QueryCommonTermsQuery CommonTermsQuery
| ConstantScoreQuery Query Boost
| QueryFunctionScoreQuery FunctionScoreQuery
| QueryDisMaxQuery DisMaxQuery
| QueryFuzzyLikeThisQuery FuzzyLikeThisQuery
| QueryFuzzyLikeFieldQuery FuzzyLikeFieldQuery
| QueryFuzzyQuery FuzzyQuery
| QueryHasChildQuery HasChildQuery
| QueryHasParentQuery HasParentQuery
| IdsQuery [DocId]
| QueryIndicesQuery IndicesQuery
| MatchAllQuery (Maybe Boost)
| QueryMoreLikeThisQuery MoreLikeThisQuery
| QueryMoreLikeThisFieldQuery MoreLikeThisFieldQuery
| QueryNestedQuery NestedQuery
| QueryPrefixQuery PrefixQuery
| QueryQueryStringQuery QueryStringQuery
| QuerySimpleQueryStringQuery SimpleQueryStringQuery
| QueryRangeQuery RangeQuery
| QueryRegexpQuery RegexpQuery
| QueryExistsQuery FieldName
| QueryMatchNoneQuery
| QueryWildcardQuery WildcardQuery
deriving (Query -> Query -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Query -> Query -> Bool
$c/= :: Query -> Query -> Bool
== :: Query -> Query -> Bool
$c== :: Query -> Query -> Bool
Eq, Int -> Query -> ShowS
[Query] -> ShowS
Query -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Query] -> ShowS
$cshowList :: [Query] -> ShowS
show :: Query -> String
$cshow :: Query -> String
showsPrec :: Int -> Query -> ShowS
$cshowsPrec :: Int -> Query -> ShowS
Show, forall x. Rep Query x -> Query
forall x. Query -> Rep Query x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Query x -> Query
$cfrom :: forall x. Query -> Rep Query x
Generic)
instance ToJSON Query where
toJSON :: Query -> Value
toJSON (TermQuery (Term Key
termQueryField Text
termQueryValue) Maybe Boost
boost) =
[Pair] -> Value
object
[ Key
"term"
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object [Key
termQueryField forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object [Pair]
merged]
]
where
base :: [Pair]
base = [Key
"value" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
termQueryValue]
boosted :: [Pair]
boosted = forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.=)) Maybe Boost
boost
merged :: [Pair]
merged = forall a. Monoid a => a -> a -> a
mappend [Pair]
base [Pair]
boosted
toJSON (TermsQuery Key
fieldName NonEmpty Text
terms) =
[Pair] -> Value
object [Key
"terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object [Pair]
conjoined]
where
conjoined :: [Pair]
conjoined = [Key
fieldName forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= NonEmpty Text
terms]
toJSON (IdsQuery [DocId]
docIds) =
[Pair] -> Value
object [Key
"ids" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object [Pair]
conjoined]
where
conjoined :: [Pair]
conjoined = [Key
"values" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. ToJSON a => a -> Value
toJSON [DocId]
docIds]
toJSON (QueryQueryStringQuery QueryStringQuery
qQueryStringQuery) =
[Pair] -> Value
object [Key
"query_string" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= QueryStringQuery
qQueryStringQuery]
toJSON (QueryMatchQuery MatchQuery
matchQuery) =
[Pair] -> Value
object [Key
"match" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= MatchQuery
matchQuery]
toJSON (QueryMultiMatchQuery MultiMatchQuery
multiMatchQuery) =
forall a. ToJSON a => a -> Value
toJSON MultiMatchQuery
multiMatchQuery
toJSON (QueryBoolQuery BoolQuery
boolQuery) =
[Pair] -> Value
object [Key
"bool" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= BoolQuery
boolQuery]
toJSON (QueryBoostingQuery BoostingQuery
boostingQuery) =
[Pair] -> Value
object [Key
"boosting" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= BoostingQuery
boostingQuery]
toJSON (QueryCommonTermsQuery CommonTermsQuery
commonTermsQuery) =
[Pair] -> Value
object [Key
"common" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= CommonTermsQuery
commonTermsQuery]
toJSON (ConstantScoreQuery Query
query Boost
boost) =
[Pair] -> Value
object
[ Key
"constant_score"
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
[ Key
"filter" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Query
query,
Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Boost
boost
]
]
toJSON (QueryFunctionScoreQuery FunctionScoreQuery
functionScoreQuery) =
[Pair] -> Value
object [Key
"function_score" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= FunctionScoreQuery
functionScoreQuery]
toJSON (QueryDisMaxQuery DisMaxQuery
disMaxQuery) =
[Pair] -> Value
object [Key
"dis_max" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= DisMaxQuery
disMaxQuery]
toJSON (QueryFuzzyLikeThisQuery FuzzyLikeThisQuery
fuzzyQuery) =
[Pair] -> Value
object [Key
"fuzzy_like_this" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= FuzzyLikeThisQuery
fuzzyQuery]
toJSON (QueryFuzzyLikeFieldQuery FuzzyLikeFieldQuery
fuzzyFieldQuery) =
[Pair] -> Value
object [Key
"fuzzy_like_this_field" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= FuzzyLikeFieldQuery
fuzzyFieldQuery]
toJSON (QueryFuzzyQuery FuzzyQuery
fuzzyQuery) =
[Pair] -> Value
object [Key
"fuzzy" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= FuzzyQuery
fuzzyQuery]
toJSON (QueryHasChildQuery HasChildQuery
childQuery) =
[Pair] -> Value
object [Key
"has_child" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= HasChildQuery
childQuery]
toJSON (QueryHasParentQuery HasParentQuery
parentQuery) =
[Pair] -> Value
object [Key
"has_parent" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= HasParentQuery
parentQuery]
toJSON (QueryIndicesQuery IndicesQuery
qIndicesQuery) =
[Pair] -> Value
object [Key
"indices" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= IndicesQuery
qIndicesQuery]
toJSON (MatchAllQuery Maybe Boost
boost) =
[Pair] -> Value
object [Key
"match_all" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost]]
toJSON (QueryMoreLikeThisQuery MoreLikeThisQuery
query) =
[Pair] -> Value
object [Key
"more_like_this" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= MoreLikeThisQuery
query]
toJSON (QueryMoreLikeThisFieldQuery MoreLikeThisFieldQuery
query) =
[Pair] -> Value
object [Key
"more_like_this_field" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= MoreLikeThisFieldQuery
query]
toJSON (QueryNestedQuery NestedQuery
query) =
[Pair] -> Value
object [Key
"nested" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= NestedQuery
query]
toJSON (QueryPrefixQuery PrefixQuery
query) =
[Pair] -> Value
object [Key
"prefix" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= PrefixQuery
query]
toJSON (QueryRangeQuery RangeQuery
query) =
[Pair] -> Value
object [Key
"range" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= RangeQuery
query]
toJSON (QueryRegexpQuery RegexpQuery
query) =
[Pair] -> Value
object [Key
"regexp" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= RegexpQuery
query]
toJSON (QuerySimpleQueryStringQuery SimpleQueryStringQuery
query) =
[Pair] -> Value
object [Key
"simple_query_string" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= SimpleQueryStringQuery
query]
toJSON (QueryExistsQuery (FieldName Text
fieldName)) =
[Pair] -> Value
object
[ Key
"exists"
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
[Key
"field" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
fieldName]
]
toJSON Query
QueryMatchNoneQuery =
[Pair] -> Value
object [Key
"match_none" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object []]
toJSON (QueryWildcardQuery WildcardQuery
query) =
[Pair] -> Value
object [Key
"wildcard" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= WildcardQuery
query]
instance FromJSON Query where
parseJSON :: Value -> Parser Query
parseJSON Value
v = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Query" Object -> Parser Query
parse Value
v
where
parse :: Object -> Parser Query
parse Object
o =
Object -> Parser Query
termQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"term"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> HashMap Key Value -> Parser Query
termsQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"terms"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Object -> Parser Query
idsQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"ids"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> QueryStringQuery -> Parser Query
queryQueryStringQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"query_string"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> MatchQuery -> Parser Query
queryMatchQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"match"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Query
queryMultiMatchQuery
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> BoolQuery -> Parser Query
queryBoolQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"bool"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> BoostingQuery -> Parser Query
queryBoostingQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"boosting"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> CommonTermsQuery -> Parser Query
queryCommonTermsQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"common"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Object -> Parser Query
constantScoreQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"constant_score"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> FunctionScoreQuery -> Parser Query
queryFunctionScoreQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"function_score"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> DisMaxQuery -> Parser Query
queryDisMaxQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"dis_max"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> FuzzyLikeThisQuery -> Parser Query
queryFuzzyLikeThisQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"fuzzy_like_this"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> FuzzyLikeFieldQuery -> Parser Query
queryFuzzyLikeFieldQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"fuzzy_like_this_field"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> FuzzyQuery -> Parser Query
queryFuzzyQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"fuzzy"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> HasChildQuery -> Parser Query
queryHasChildQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"has_child"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> HasParentQuery -> Parser Query
queryHasParentQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"has_parent"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> IndicesQuery -> Parser Query
queryIndicesQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"indices"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Object -> Parser Query
matchAllQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"match_all"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> MoreLikeThisQuery -> Parser Query
queryMoreLikeThisQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"more_like_this"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> MoreLikeThisFieldQuery -> Parser Query
queryMoreLikeThisFieldQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"more_like_this_field"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NestedQuery -> Parser Query
queryNestedQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"nested"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> PrefixQuery -> Parser Query
queryPrefixQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"prefix"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RangeQuery -> Parser Query
queryRangeQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"range"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RegexpQuery -> Parser Query
queryRegexpQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"regexp"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> SimpleQueryStringQuery -> Parser Query
querySimpleQueryStringQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"simple_query_string"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> WildcardQuery -> Parser Query
queryWildcardQuery
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"wildcard"
where
taggedWith :: (a -> Parser b) -> Key -> Parser b
taggedWith a -> Parser b
parser Key
k = a -> Parser b
parser forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
k
termQuery :: Object -> Parser Query
termQuery = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \(FieldName Text
fn) Object
o ->
Term -> Maybe Boost -> Query
TermQuery forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Key -> Text -> Term
Term (Text -> Key
fromText Text
fn) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value") forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
termsQuery :: HashMap Key Value -> Parser Query
termsQuery HashMap Key Value
o = case forall k v. HashMap k v -> [(k, v)]
HM.toList HashMap Key Value
o of
[(Key
fn, Value
vs)] -> do
[Text]
vals <- forall a. FromJSON a => Value -> Parser a
parseJSON Value
vs
case [Text]
vals of
Text
x : [Text]
xs -> forall (m :: * -> *) a. Monad m => a -> m a
return (Key -> NonEmpty Text -> Query
TermsQuery Key
fn (Text
x forall a. a -> [a] -> NonEmpty a
:| [Text]
xs))
[Text]
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Expected non empty list of values"
[Pair]
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Expected object with 1 field-named key"
idsQuery :: Object -> Parser Query
idsQuery Object
o = [DocId] -> Query
IdsQuery forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"values"
queryQueryStringQuery :: QueryStringQuery -> Parser Query
queryQueryStringQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. QueryStringQuery -> Query
QueryQueryStringQuery
queryMatchQuery :: MatchQuery -> Parser Query
queryMatchQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. MatchQuery -> Query
QueryMatchQuery
queryMultiMatchQuery :: Parser Query
queryMultiMatchQuery = MultiMatchQuery -> Query
QueryMultiMatchQuery forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
queryBoolQuery :: BoolQuery -> Parser Query
queryBoolQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. BoolQuery -> Query
QueryBoolQuery
queryBoostingQuery :: BoostingQuery -> Parser Query
queryBoostingQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. BoostingQuery -> Query
QueryBoostingQuery
queryCommonTermsQuery :: CommonTermsQuery -> Parser Query
queryCommonTermsQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. CommonTermsQuery -> Query
QueryCommonTermsQuery
constantScoreQuery :: Object -> Parser Query
constantScoreQuery Object
o = case forall v. Key -> KeyMap v -> Maybe v
X.lookup Key
"filter" Object
o of
Just Value
x ->
Query -> Boost -> Query
ConstantScoreQuery
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => Value -> Parser a
parseJSON Value
x
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"boost"
Maybe Value
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Does not appear to be a ConstantScoreQuery"
queryFunctionScoreQuery :: FunctionScoreQuery -> Parser Query
queryFunctionScoreQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. FunctionScoreQuery -> Query
QueryFunctionScoreQuery
queryDisMaxQuery :: DisMaxQuery -> Parser Query
queryDisMaxQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. DisMaxQuery -> Query
QueryDisMaxQuery
queryFuzzyLikeThisQuery :: FuzzyLikeThisQuery -> Parser Query
queryFuzzyLikeThisQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. FuzzyLikeThisQuery -> Query
QueryFuzzyLikeThisQuery
queryFuzzyLikeFieldQuery :: FuzzyLikeFieldQuery -> Parser Query
queryFuzzyLikeFieldQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. FuzzyLikeFieldQuery -> Query
QueryFuzzyLikeFieldQuery
queryFuzzyQuery :: FuzzyQuery -> Parser Query
queryFuzzyQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. FuzzyQuery -> Query
QueryFuzzyQuery
queryHasChildQuery :: HasChildQuery -> Parser Query
queryHasChildQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasChildQuery -> Query
QueryHasChildQuery
queryHasParentQuery :: HasParentQuery -> Parser Query
queryHasParentQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasParentQuery -> Query
QueryHasParentQuery
queryIndicesQuery :: IndicesQuery -> Parser Query
queryIndicesQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. IndicesQuery -> Query
QueryIndicesQuery
matchAllQuery :: Object -> Parser Query
matchAllQuery Object
o = Maybe Boost -> Query
MatchAllQuery forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
queryMoreLikeThisQuery :: MoreLikeThisQuery -> Parser Query
queryMoreLikeThisQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. MoreLikeThisQuery -> Query
QueryMoreLikeThisQuery
queryMoreLikeThisFieldQuery :: MoreLikeThisFieldQuery -> Parser Query
queryMoreLikeThisFieldQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. MoreLikeThisFieldQuery -> Query
QueryMoreLikeThisFieldQuery
queryNestedQuery :: NestedQuery -> Parser Query
queryNestedQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedQuery -> Query
QueryNestedQuery
queryPrefixQuery :: PrefixQuery -> Parser Query
queryPrefixQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrefixQuery -> Query
QueryPrefixQuery
queryRangeQuery :: RangeQuery -> Parser Query
queryRangeQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. RangeQuery -> Query
QueryRangeQuery
queryRegexpQuery :: RegexpQuery -> Parser Query
queryRegexpQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. RegexpQuery -> Query
QueryRegexpQuery
querySimpleQueryStringQuery :: SimpleQueryStringQuery -> Parser Query
querySimpleQueryStringQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. SimpleQueryStringQuery -> Query
QuerySimpleQueryStringQuery
queryWildcardQuery :: WildcardQuery -> Parser Query
queryWildcardQuery = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. WildcardQuery -> Query
QueryWildcardQuery
newtype Filter = Filter {Filter -> Query
unFilter :: Query}
deriving (Filter -> Filter -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Filter -> Filter -> Bool
$c/= :: Filter -> Filter -> Bool
== :: Filter -> Filter -> Bool
$c== :: Filter -> Filter -> Bool
Eq, Int -> Filter -> ShowS
[Filter] -> ShowS
Filter -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Filter] -> ShowS
$cshowList :: [Filter] -> ShowS
show :: Filter -> String
$cshow :: Filter -> String
showsPrec :: Int -> Filter -> ShowS
$cshowsPrec :: Int -> Filter -> ShowS
Show)
instance ToJSON Filter where
toJSON :: Filter -> Value
toJSON = forall a. ToJSON a => a -> Value
toJSON forall b c a. (b -> c) -> (a -> b) -> a -> c
. Filter -> Query
unFilter
instance FromJSON Filter where
parseJSON :: Value -> Parser Filter
parseJSON Value
v = Query -> Filter
Filter forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
data RegexpQuery = RegexpQuery
{ RegexpQuery -> FieldName
regexpQueryField :: FieldName,
RegexpQuery -> Regexp
regexpQuery :: Regexp,
RegexpQuery -> RegexpFlags
regexpQueryFlags :: RegexpFlags,
RegexpQuery -> Maybe Boost
regexpQueryBoost :: Maybe Boost
}
deriving (RegexpQuery -> RegexpQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegexpQuery -> RegexpQuery -> Bool
$c/= :: RegexpQuery -> RegexpQuery -> Bool
== :: RegexpQuery -> RegexpQuery -> Bool
$c== :: RegexpQuery -> RegexpQuery -> Bool
Eq, Int -> RegexpQuery -> ShowS
[RegexpQuery] -> ShowS
RegexpQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegexpQuery] -> ShowS
$cshowList :: [RegexpQuery] -> ShowS
show :: RegexpQuery -> String
$cshow :: RegexpQuery -> String
showsPrec :: Int -> RegexpQuery -> ShowS
$cshowsPrec :: Int -> RegexpQuery -> ShowS
Show, forall x. Rep RegexpQuery x -> RegexpQuery
forall x. RegexpQuery -> Rep RegexpQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RegexpQuery x -> RegexpQuery
$cfrom :: forall x. RegexpQuery -> Rep RegexpQuery x
Generic)
instance ToJSON RegexpQuery where
toJSON :: RegexpQuery -> Value
toJSON
( RegexpQuery
(FieldName Text
rqQueryField)
(Regexp Text
regexpQueryQuery)
RegexpFlags
rqQueryFlags
Maybe Boost
rqQueryBoost
) =
[Pair] -> Value
object [Text -> Key
fromText Text
rqQueryField forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
where
base :: [Pair]
base =
[ Key
"value" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
regexpQueryQuery,
Key
"flags" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= RegexpFlags
rqQueryFlags,
Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
rqQueryBoost
]
instance FromJSON RegexpQuery where
parseJSON :: Value -> Parser RegexpQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"RegexpQuery" Object -> Parser RegexpQuery
parse
where
parse :: Object -> Parser RegexpQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
FieldName -> Regexp -> RegexpFlags -> Maybe Boost -> RegexpQuery
RegexpQuery FieldName
fn
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"flags"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
data WildcardQuery = WildcardQuery
{ WildcardQuery -> FieldName
wildcardQueryField :: FieldName,
WildcardQuery -> Key
wildcardQuery :: Key,
WildcardQuery -> Maybe Boost
wildcardQueryBoost :: Maybe Boost
}
deriving (WildcardQuery -> WildcardQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WildcardQuery -> WildcardQuery -> Bool
$c/= :: WildcardQuery -> WildcardQuery -> Bool
== :: WildcardQuery -> WildcardQuery -> Bool
$c== :: WildcardQuery -> WildcardQuery -> Bool
Eq, Int -> WildcardQuery -> ShowS
[WildcardQuery] -> ShowS
WildcardQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WildcardQuery] -> ShowS
$cshowList :: [WildcardQuery] -> ShowS
show :: WildcardQuery -> String
$cshow :: WildcardQuery -> String
showsPrec :: Int -> WildcardQuery -> ShowS
$cshowsPrec :: Int -> WildcardQuery -> ShowS
Show, forall x. Rep WildcardQuery x -> WildcardQuery
forall x. WildcardQuery -> Rep WildcardQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep WildcardQuery x -> WildcardQuery
$cfrom :: forall x. WildcardQuery -> Rep WildcardQuery x
Generic)
instance ToJSON WildcardQuery where
toJSON :: WildcardQuery -> Value
toJSON
( WildcardQuery
(FieldName Text
wcQueryField)
(Key
wcQueryQuery)
Maybe Boost
wcQueryBoost
) =
[Pair] -> Value
object [Text -> Key
fromText Text
wcQueryField forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
where
base :: [Pair]
base =
[ Key
"value" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Key
wcQueryQuery,
Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
wcQueryBoost
]
instance FromJSON WildcardQuery where
parseJSON :: Value -> Parser WildcardQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"WildcardQuery" Object -> Parser WildcardQuery
parse
where
parse :: Object -> Parser WildcardQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
FieldName -> Key -> Maybe Boost -> WildcardQuery
WildcardQuery FieldName
fn
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
data RangeQuery = RangeQuery
{ RangeQuery -> FieldName
rangeQueryField :: FieldName,
RangeQuery -> RangeValue
rangeQueryRange :: RangeValue,
RangeQuery -> Boost
rangeQueryBoost :: Boost
}
deriving (RangeQuery -> RangeQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RangeQuery -> RangeQuery -> Bool
$c/= :: RangeQuery -> RangeQuery -> Bool
== :: RangeQuery -> RangeQuery -> Bool
$c== :: RangeQuery -> RangeQuery -> Bool
Eq, Int -> RangeQuery -> ShowS
[RangeQuery] -> ShowS
RangeQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RangeQuery] -> ShowS
$cshowList :: [RangeQuery] -> ShowS
show :: RangeQuery -> String
$cshow :: RangeQuery -> String
showsPrec :: Int -> RangeQuery -> ShowS
$cshowsPrec :: Int -> RangeQuery -> ShowS
Show, forall x. Rep RangeQuery x -> RangeQuery
forall x. RangeQuery -> Rep RangeQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RangeQuery x -> RangeQuery
$cfrom :: forall x. RangeQuery -> Rep RangeQuery x
Generic)
instance ToJSON RangeQuery where
toJSON :: RangeQuery -> Value
toJSON (RangeQuery (FieldName Text
fieldName) RangeValue
range Boost
boost) =
[Pair] -> Value
object [Text -> Key
fromText Text
fieldName forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object [Pair]
conjoined]
where
conjoined :: [Pair]
conjoined = (Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Boost
boost) forall a. a -> [a] -> [a]
: RangeValue -> [Pair]
rangeValueToPair RangeValue
range
instance FromJSON RangeQuery where
parseJSON :: Value -> Parser RangeQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"RangeQuery" Object -> Parser RangeQuery
parse
where
parse :: Object -> Parser RangeQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
FieldName -> RangeValue -> Boost -> RangeQuery
RangeQuery FieldName
fn
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => Value -> Parser a
parseJSON (Object -> Value
Object Object
o)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"boost"
mkRangeQuery :: FieldName -> RangeValue -> RangeQuery
mkRangeQuery :: FieldName -> RangeValue -> RangeQuery
mkRangeQuery FieldName
f RangeValue
r = FieldName -> RangeValue -> Boost -> RangeQuery
RangeQuery FieldName
f RangeValue
r (Double -> Boost
Boost Double
1.0)
data SimpleQueryStringQuery = SimpleQueryStringQuery
{ SimpleQueryStringQuery -> QueryString
simpleQueryStringQuery :: QueryString,
SimpleQueryStringQuery -> Maybe FieldOrFields
simpleQueryStringField :: Maybe FieldOrFields,
SimpleQueryStringQuery -> Maybe BooleanOperator
simpleQueryStringOperator :: Maybe BooleanOperator,
SimpleQueryStringQuery -> Maybe Analyzer
simpleQueryStringAnalyzer :: Maybe Analyzer,
SimpleQueryStringQuery -> Maybe (NonEmpty SimpleQueryFlag)
simpleQueryStringFlags :: Maybe (NonEmpty SimpleQueryFlag),
SimpleQueryStringQuery -> Maybe LowercaseExpanded
simpleQueryStringLowercaseExpanded :: Maybe LowercaseExpanded,
SimpleQueryStringQuery -> Maybe Locale
simpleQueryStringLocale :: Maybe Locale
}
deriving (SimpleQueryStringQuery -> SimpleQueryStringQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SimpleQueryStringQuery -> SimpleQueryStringQuery -> Bool
$c/= :: SimpleQueryStringQuery -> SimpleQueryStringQuery -> Bool
== :: SimpleQueryStringQuery -> SimpleQueryStringQuery -> Bool
$c== :: SimpleQueryStringQuery -> SimpleQueryStringQuery -> Bool
Eq, Int -> SimpleQueryStringQuery -> ShowS
[SimpleQueryStringQuery] -> ShowS
SimpleQueryStringQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SimpleQueryStringQuery] -> ShowS
$cshowList :: [SimpleQueryStringQuery] -> ShowS
show :: SimpleQueryStringQuery -> String
$cshow :: SimpleQueryStringQuery -> String
showsPrec :: Int -> SimpleQueryStringQuery -> ShowS
$cshowsPrec :: Int -> SimpleQueryStringQuery -> ShowS
Show, forall x. Rep SimpleQueryStringQuery x -> SimpleQueryStringQuery
forall x. SimpleQueryStringQuery -> Rep SimpleQueryStringQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SimpleQueryStringQuery x -> SimpleQueryStringQuery
$cfrom :: forall x. SimpleQueryStringQuery -> Rep SimpleQueryStringQuery x
Generic)
instance ToJSON SimpleQueryStringQuery where
toJSON :: SimpleQueryStringQuery -> Value
toJSON SimpleQueryStringQuery {Maybe (NonEmpty SimpleQueryFlag)
Maybe Locale
Maybe LowercaseExpanded
Maybe Analyzer
Maybe BooleanOperator
Maybe FieldOrFields
QueryString
simpleQueryStringLocale :: Maybe Locale
simpleQueryStringLowercaseExpanded :: Maybe LowercaseExpanded
simpleQueryStringFlags :: Maybe (NonEmpty SimpleQueryFlag)
simpleQueryStringAnalyzer :: Maybe Analyzer
simpleQueryStringOperator :: Maybe BooleanOperator
simpleQueryStringField :: Maybe FieldOrFields
simpleQueryStringQuery :: QueryString
simpleQueryStringLocale :: SimpleQueryStringQuery -> Maybe Locale
simpleQueryStringLowercaseExpanded :: SimpleQueryStringQuery -> Maybe LowercaseExpanded
simpleQueryStringFlags :: SimpleQueryStringQuery -> Maybe (NonEmpty SimpleQueryFlag)
simpleQueryStringAnalyzer :: SimpleQueryStringQuery -> Maybe Analyzer
simpleQueryStringOperator :: SimpleQueryStringQuery -> Maybe BooleanOperator
simpleQueryStringField :: SimpleQueryStringQuery -> Maybe FieldOrFields
simpleQueryStringQuery :: SimpleQueryStringQuery -> QueryString
..} =
[Pair] -> Value
omitNulls ([Pair]
base forall a. [a] -> [a] -> [a]
++ [Pair]
maybeAdd)
where
base :: [Pair]
base = [Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= QueryString
simpleQueryStringQuery]
maybeAdd :: [Pair]
maybeAdd =
[ Key
"fields" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe FieldOrFields
simpleQueryStringField,
Key
"default_operator" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe BooleanOperator
simpleQueryStringOperator,
Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
simpleQueryStringAnalyzer,
Key
"flags" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe (NonEmpty SimpleQueryFlag)
simpleQueryStringFlags,
Key
"lowercase_expanded_terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe LowercaseExpanded
simpleQueryStringLowercaseExpanded,
Key
"locale" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Locale
simpleQueryStringLocale
]
instance FromJSON SimpleQueryStringQuery where
parseJSON :: Value -> Parser SimpleQueryStringQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"SimpleQueryStringQuery" Object -> Parser SimpleQueryStringQuery
parse
where
parse :: Object -> Parser SimpleQueryStringQuery
parse Object
o =
QueryString
-> Maybe FieldOrFields
-> Maybe BooleanOperator
-> Maybe Analyzer
-> Maybe (NonEmpty SimpleQueryFlag)
-> Maybe LowercaseExpanded
-> Maybe Locale
-> SimpleQueryStringQuery
SimpleQueryStringQuery
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fields"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"default_operator"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall {a}. Maybe [a] -> Maybe (NonEmpty a)
parseFlags forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"flags")
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"lowercase_expanded_terms"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"locale"
parseFlags :: Maybe [a] -> Maybe (NonEmpty a)
parseFlags (Just (a
x : [a]
xs)) = forall a. a -> Maybe a
Just (a
x forall a. a -> [a] -> NonEmpty a
:| [a]
xs)
parseFlags Maybe [a]
_ = forall a. Maybe a
Nothing
data SimpleQueryFlag
= SimpleQueryAll
| SimpleQueryNone
| SimpleQueryAnd
| SimpleQueryOr
| SimpleQueryPrefix
| SimpleQueryPhrase
| SimpleQueryPrecedence
| SimpleQueryEscape
| SimpleQueryWhitespace
| SimpleQueryFuzzy
| SimpleQueryNear
| SimpleQuerySlop
deriving (SimpleQueryFlag -> SimpleQueryFlag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SimpleQueryFlag -> SimpleQueryFlag -> Bool
$c/= :: SimpleQueryFlag -> SimpleQueryFlag -> Bool
== :: SimpleQueryFlag -> SimpleQueryFlag -> Bool
$c== :: SimpleQueryFlag -> SimpleQueryFlag -> Bool
Eq, Int -> SimpleQueryFlag -> ShowS
[SimpleQueryFlag] -> ShowS
SimpleQueryFlag -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SimpleQueryFlag] -> ShowS
$cshowList :: [SimpleQueryFlag] -> ShowS
show :: SimpleQueryFlag -> String
$cshow :: SimpleQueryFlag -> String
showsPrec :: Int -> SimpleQueryFlag -> ShowS
$cshowsPrec :: Int -> SimpleQueryFlag -> ShowS
Show, forall x. Rep SimpleQueryFlag x -> SimpleQueryFlag
forall x. SimpleQueryFlag -> Rep SimpleQueryFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SimpleQueryFlag x -> SimpleQueryFlag
$cfrom :: forall x. SimpleQueryFlag -> Rep SimpleQueryFlag x
Generic)
instance ToJSON SimpleQueryFlag where
toJSON :: SimpleQueryFlag -> Value
toJSON SimpleQueryFlag
SimpleQueryAll = Value
"ALL"
toJSON SimpleQueryFlag
SimpleQueryNone = Value
"NONE"
toJSON SimpleQueryFlag
SimpleQueryAnd = Value
"AND"
toJSON SimpleQueryFlag
SimpleQueryOr = Value
"OR"
toJSON SimpleQueryFlag
SimpleQueryPrefix = Value
"PREFIX"
toJSON SimpleQueryFlag
SimpleQueryPhrase = Value
"PHRASE"
toJSON SimpleQueryFlag
SimpleQueryPrecedence = Value
"PRECEDENCE"
toJSON SimpleQueryFlag
SimpleQueryEscape = Value
"ESCAPE"
toJSON SimpleQueryFlag
SimpleQueryWhitespace = Value
"WHITESPACE"
toJSON SimpleQueryFlag
SimpleQueryFuzzy = Value
"FUZZY"
toJSON SimpleQueryFlag
SimpleQueryNear = Value
"NEAR"
toJSON SimpleQueryFlag
SimpleQuerySlop = Value
"SLOP"
instance FromJSON SimpleQueryFlag where
parseJSON :: Value -> Parser SimpleQueryFlag
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"SimpleQueryFlag" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f SimpleQueryFlag
parse
where
parse :: a -> f SimpleQueryFlag
parse a
"ALL" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryAll
parse a
"NONE" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryNone
parse a
"AND" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryAnd
parse a
"OR" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryOr
parse a
"PREFIX" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryPrefix
parse a
"PHRASE" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryPhrase
parse a
"PRECEDENCE" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryPrecedence
parse a
"ESCAPE" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryEscape
parse a
"WHITESPACE" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryWhitespace
parse a
"FUZZY" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryFuzzy
parse a
"NEAR" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQueryNear
parse a
"SLOP" = forall (f :: * -> *) a. Applicative f => a -> f a
pure SimpleQueryFlag
SimpleQuerySlop
parse a
f = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unexpected SimpleQueryFlag: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
f)
data QueryStringQuery = QueryStringQuery
{ QueryStringQuery -> QueryString
queryStringQuery :: QueryString,
QueryStringQuery -> Maybe FieldName
queryStringDefaultField :: Maybe FieldName,
QueryStringQuery -> Maybe BooleanOperator
queryStringOperator :: Maybe BooleanOperator,
QueryStringQuery -> Maybe Analyzer
queryStringAnalyzer :: Maybe Analyzer,
QueryStringQuery -> Maybe AllowLeadingWildcard
queryStringAllowLeadingWildcard :: Maybe AllowLeadingWildcard,
QueryStringQuery -> Maybe LowercaseExpanded
queryStringLowercaseExpanded :: Maybe LowercaseExpanded,
QueryStringQuery -> Maybe EnablePositionIncrements
queryStringEnablePositionIncrements :: Maybe EnablePositionIncrements,
QueryStringQuery -> Maybe MaxExpansions
queryStringFuzzyMaxExpansions :: Maybe MaxExpansions,
QueryStringQuery -> Maybe Fuzziness
queryStringFuzziness :: Maybe Fuzziness,
QueryStringQuery -> Maybe PrefixLength
queryStringFuzzyPrefixLength :: Maybe PrefixLength,
QueryStringQuery -> Maybe PhraseSlop
queryStringPhraseSlop :: Maybe PhraseSlop,
QueryStringQuery -> Maybe Boost
queryStringBoost :: Maybe Boost,
QueryStringQuery -> Maybe AnalyzeWildcard
queryStringAnalyzeWildcard :: Maybe AnalyzeWildcard,
QueryStringQuery -> Maybe GeneratePhraseQueries
queryStringGeneratePhraseQueries :: Maybe GeneratePhraseQueries,
QueryStringQuery -> Maybe MinimumMatch
queryStringMinimumShouldMatch :: Maybe MinimumMatch,
QueryStringQuery -> Maybe Lenient
queryStringLenient :: Maybe Lenient,
QueryStringQuery -> Maybe Locale
queryStringLocale :: Maybe Locale
}
deriving (QueryStringQuery -> QueryStringQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: QueryStringQuery -> QueryStringQuery -> Bool
$c/= :: QueryStringQuery -> QueryStringQuery -> Bool
== :: QueryStringQuery -> QueryStringQuery -> Bool
$c== :: QueryStringQuery -> QueryStringQuery -> Bool
Eq, Int -> QueryStringQuery -> ShowS
[QueryStringQuery] -> ShowS
QueryStringQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [QueryStringQuery] -> ShowS
$cshowList :: [QueryStringQuery] -> ShowS
show :: QueryStringQuery -> String
$cshow :: QueryStringQuery -> String
showsPrec :: Int -> QueryStringQuery -> ShowS
$cshowsPrec :: Int -> QueryStringQuery -> ShowS
Show, forall x. Rep QueryStringQuery x -> QueryStringQuery
forall x. QueryStringQuery -> Rep QueryStringQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep QueryStringQuery x -> QueryStringQuery
$cfrom :: forall x. QueryStringQuery -> Rep QueryStringQuery x
Generic)
instance ToJSON QueryStringQuery where
toJSON :: QueryStringQuery -> Value
toJSON
( QueryStringQuery
QueryString
qsQueryString
Maybe FieldName
qsDefaultField
Maybe BooleanOperator
qsOperator
Maybe Analyzer
qsAnalyzer
Maybe AllowLeadingWildcard
qsAllowWildcard
Maybe LowercaseExpanded
qsLowercaseExpanded
Maybe EnablePositionIncrements
qsEnablePositionIncrements
Maybe MaxExpansions
qsFuzzyMaxExpansions
Maybe Fuzziness
qsFuzziness
Maybe PrefixLength
qsFuzzyPrefixLength
Maybe PhraseSlop
qsPhraseSlop
Maybe Boost
qsBoost
Maybe AnalyzeWildcard
qsAnalyzeWildcard
Maybe GeneratePhraseQueries
qsGeneratePhraseQueries
Maybe MinimumMatch
qsMinimumShouldMatch
Maybe Lenient
qsLenient
Maybe Locale
qsLocale
) =
[Pair] -> Value
omitNulls [Pair]
base
where
base :: [Pair]
base =
[ Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= QueryString
qsQueryString,
Key
"default_field" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe FieldName
qsDefaultField,
Key
"default_operator" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe BooleanOperator
qsOperator,
Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
qsAnalyzer,
Key
"allow_leading_wildcard" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe AllowLeadingWildcard
qsAllowWildcard,
Key
"lowercase_expanded_terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe LowercaseExpanded
qsLowercaseExpanded,
Key
"enable_position_increments" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe EnablePositionIncrements
qsEnablePositionIncrements,
Key
"fuzzy_max_expansions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxExpansions
qsFuzzyMaxExpansions,
Key
"fuzziness" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Fuzziness
qsFuzziness,
Key
"fuzzy_prefix_length" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe PrefixLength
qsFuzzyPrefixLength,
Key
"phrase_slop" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe PhraseSlop
qsPhraseSlop,
Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
qsBoost,
Key
"analyze_wildcard" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe AnalyzeWildcard
qsAnalyzeWildcard,
Key
"auto_generate_phrase_queries" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe GeneratePhraseQueries
qsGeneratePhraseQueries,
Key
"minimum_should_match" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinimumMatch
qsMinimumShouldMatch,
Key
"lenient" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Lenient
qsLenient,
Key
"locale" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Locale
qsLocale
]
instance FromJSON QueryStringQuery where
parseJSON :: Value -> Parser QueryStringQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"QueryStringQuery" Object -> Parser QueryStringQuery
parse
where
parse :: Object -> Parser QueryStringQuery
parse Object
o =
QueryString
-> Maybe FieldName
-> Maybe BooleanOperator
-> Maybe Analyzer
-> Maybe AllowLeadingWildcard
-> Maybe LowercaseExpanded
-> Maybe EnablePositionIncrements
-> Maybe MaxExpansions
-> Maybe Fuzziness
-> Maybe PrefixLength
-> Maybe PhraseSlop
-> Maybe Boost
-> Maybe AnalyzeWildcard
-> Maybe GeneratePhraseQueries
-> Maybe MinimumMatch
-> Maybe Lenient
-> Maybe Locale
-> QueryStringQuery
QueryStringQuery
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"default_field"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"default_operator"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"allow_leading_wildcard"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"lowercase_expanded_terms"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"enable_position_increments"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fuzzy_max_expansions"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fuzziness"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fuzzy_prefix_length"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"phrase_slop"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyze_wildcard"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"auto_generate_phrase_queries"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"minimum_should_match"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"lenient"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"locale"
mkQueryStringQuery :: QueryString -> QueryStringQuery
mkQueryStringQuery :: QueryString -> QueryStringQuery
mkQueryStringQuery QueryString
qs =
QueryString
-> Maybe FieldName
-> Maybe BooleanOperator
-> Maybe Analyzer
-> Maybe AllowLeadingWildcard
-> Maybe LowercaseExpanded
-> Maybe EnablePositionIncrements
-> Maybe MaxExpansions
-> Maybe Fuzziness
-> Maybe PrefixLength
-> Maybe PhraseSlop
-> Maybe Boost
-> Maybe AnalyzeWildcard
-> Maybe GeneratePhraseQueries
-> Maybe MinimumMatch
-> Maybe Lenient
-> Maybe Locale
-> QueryStringQuery
QueryStringQuery
QueryString
qs
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
data FieldOrFields
= FofField FieldName
| FofFields (NonEmpty FieldName)
deriving (FieldOrFields -> FieldOrFields -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FieldOrFields -> FieldOrFields -> Bool
$c/= :: FieldOrFields -> FieldOrFields -> Bool
== :: FieldOrFields -> FieldOrFields -> Bool
$c== :: FieldOrFields -> FieldOrFields -> Bool
Eq, Int -> FieldOrFields -> ShowS
[FieldOrFields] -> ShowS
FieldOrFields -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FieldOrFields] -> ShowS
$cshowList :: [FieldOrFields] -> ShowS
show :: FieldOrFields -> String
$cshow :: FieldOrFields -> String
showsPrec :: Int -> FieldOrFields -> ShowS
$cshowsPrec :: Int -> FieldOrFields -> ShowS
Show, forall x. Rep FieldOrFields x -> FieldOrFields
forall x. FieldOrFields -> Rep FieldOrFields x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FieldOrFields x -> FieldOrFields
$cfrom :: forall x. FieldOrFields -> Rep FieldOrFields x
Generic)
instance ToJSON FieldOrFields where
toJSON :: FieldOrFields -> Value
toJSON (FofField FieldName
fieldName) =
forall a. ToJSON a => a -> Value
toJSON FieldName
fieldName
toJSON (FofFields NonEmpty FieldName
fieldNames) =
forall a. ToJSON a => a -> Value
toJSON NonEmpty FieldName
fieldNames
instance FromJSON FieldOrFields where
parseJSON :: Value -> Parser FieldOrFields
parseJSON Value
v =
FieldName -> FieldOrFields
FofField forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NonEmpty FieldName -> FieldOrFields
FofFields forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a. FromJSON a => [Value] -> Parser (NonEmpty a)
parseNEJSON forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a. FromJSON a => Value -> Parser a
parseJSON Value
v)
data PrefixQuery = PrefixQuery
{ PrefixQuery -> FieldName
prefixQueryField :: FieldName,
PrefixQuery -> Text
prefixQueryPrefixValue :: Text,
PrefixQuery -> Maybe Boost
prefixQueryBoost :: Maybe Boost
}
deriving (PrefixQuery -> PrefixQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrefixQuery -> PrefixQuery -> Bool
$c/= :: PrefixQuery -> PrefixQuery -> Bool
== :: PrefixQuery -> PrefixQuery -> Bool
$c== :: PrefixQuery -> PrefixQuery -> Bool
Eq, Int -> PrefixQuery -> ShowS
[PrefixQuery] -> ShowS
PrefixQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrefixQuery] -> ShowS
$cshowList :: [PrefixQuery] -> ShowS
show :: PrefixQuery -> String
$cshow :: PrefixQuery -> String
showsPrec :: Int -> PrefixQuery -> ShowS
$cshowsPrec :: Int -> PrefixQuery -> ShowS
Show, forall x. Rep PrefixQuery x -> PrefixQuery
forall x. PrefixQuery -> Rep PrefixQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PrefixQuery x -> PrefixQuery
$cfrom :: forall x. PrefixQuery -> Rep PrefixQuery x
Generic)
instance ToJSON PrefixQuery where
toJSON :: PrefixQuery -> Value
toJSON (PrefixQuery (FieldName Text
fieldName) Text
queryValue Maybe Boost
boost) =
[Pair] -> Value
object [Text -> Key
fromText Text
fieldName forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
where
base :: [Pair]
base =
[ Key
"value" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
queryValue,
Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost
]
instance FromJSON PrefixQuery where
parseJSON :: Value -> Parser PrefixQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"PrefixQuery" Object -> Parser PrefixQuery
parse
where
parse :: Object -> Parser PrefixQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
FieldName -> Text -> Maybe Boost -> PrefixQuery
PrefixQuery FieldName
fn
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
data NestedQuery = NestedQuery
{ NestedQuery -> QueryPath
nestedQueryPath :: QueryPath,
NestedQuery -> ScoreType
nestedQueryScoreType :: ScoreType,
NestedQuery -> Query
nestedQuery :: Query,
NestedQuery -> Maybe InnerHits
nestedQueryInnerHits :: Maybe InnerHits
}
deriving (NestedQuery -> NestedQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NestedQuery -> NestedQuery -> Bool
$c/= :: NestedQuery -> NestedQuery -> Bool
== :: NestedQuery -> NestedQuery -> Bool
$c== :: NestedQuery -> NestedQuery -> Bool
Eq, Int -> NestedQuery -> ShowS
[NestedQuery] -> ShowS
NestedQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NestedQuery] -> ShowS
$cshowList :: [NestedQuery] -> ShowS
show :: NestedQuery -> String
$cshow :: NestedQuery -> String
showsPrec :: Int -> NestedQuery -> ShowS
$cshowsPrec :: Int -> NestedQuery -> ShowS
Show, forall x. Rep NestedQuery x -> NestedQuery
forall x. NestedQuery -> Rep NestedQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NestedQuery x -> NestedQuery
$cfrom :: forall x. NestedQuery -> Rep NestedQuery x
Generic)
instance ToJSON NestedQuery where
toJSON :: NestedQuery -> Value
toJSON (NestedQuery QueryPath
nqPath ScoreType
nqScoreType Query
nqQuery Maybe InnerHits
nqInnerHits) =
[Pair] -> Value
omitNulls
[ Key
"path" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= QueryPath
nqPath,
Key
"score_mode" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= ScoreType
nqScoreType,
Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Query
nqQuery,
Key
"inner_hits" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe InnerHits
nqInnerHits
]
instance FromJSON NestedQuery where
parseJSON :: Value -> Parser NestedQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"NestedQuery" Object -> Parser NestedQuery
parse
where
parse :: Object -> Parser NestedQuery
parse Object
o =
QueryPath -> ScoreType -> Query -> Maybe InnerHits -> NestedQuery
NestedQuery
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"score_mode"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"inner_hits"
data MoreLikeThisFieldQuery = MoreLikeThisFieldQuery
{ MoreLikeThisFieldQuery -> Text
moreLikeThisFieldText :: Text,
MoreLikeThisFieldQuery -> FieldName
moreLikeThisFieldFields :: FieldName,
MoreLikeThisFieldQuery -> Maybe PercentMatch
moreLikeThisFieldPercentMatch :: Maybe PercentMatch,
MoreLikeThisFieldQuery -> Maybe MinimumTermFrequency
moreLikeThisFieldMinimumTermFreq :: Maybe MinimumTermFrequency,
MoreLikeThisFieldQuery -> Maybe MaxQueryTerms
moreLikeThisFieldMaxQueryTerms :: Maybe MaxQueryTerms,
MoreLikeThisFieldQuery -> Maybe (NonEmpty StopWord)
moreLikeThisFieldStopWords :: Maybe (NonEmpty StopWord),
MoreLikeThisFieldQuery -> Maybe MinDocFrequency
moreLikeThisFieldMinDocFrequency :: Maybe MinDocFrequency,
MoreLikeThisFieldQuery -> Maybe MaxDocFrequency
moreLikeThisFieldMaxDocFrequency :: Maybe MaxDocFrequency,
MoreLikeThisFieldQuery -> Maybe MinWordLength
moreLikeThisFieldMinWordLength :: Maybe MinWordLength,
MoreLikeThisFieldQuery -> Maybe MaxWordLength
moreLikeThisFieldMaxWordLength :: Maybe MaxWordLength,
MoreLikeThisFieldQuery -> Maybe BoostTerms
moreLikeThisFieldBoostTerms :: Maybe BoostTerms,
MoreLikeThisFieldQuery -> Maybe Boost
moreLikeThisFieldBoost :: Maybe Boost,
MoreLikeThisFieldQuery -> Maybe Analyzer
moreLikeThisFieldAnalyzer :: Maybe Analyzer
}
deriving (MoreLikeThisFieldQuery -> MoreLikeThisFieldQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MoreLikeThisFieldQuery -> MoreLikeThisFieldQuery -> Bool
$c/= :: MoreLikeThisFieldQuery -> MoreLikeThisFieldQuery -> Bool
== :: MoreLikeThisFieldQuery -> MoreLikeThisFieldQuery -> Bool
$c== :: MoreLikeThisFieldQuery -> MoreLikeThisFieldQuery -> Bool
Eq, Int -> MoreLikeThisFieldQuery -> ShowS
[MoreLikeThisFieldQuery] -> ShowS
MoreLikeThisFieldQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MoreLikeThisFieldQuery] -> ShowS
$cshowList :: [MoreLikeThisFieldQuery] -> ShowS
show :: MoreLikeThisFieldQuery -> String
$cshow :: MoreLikeThisFieldQuery -> String
showsPrec :: Int -> MoreLikeThisFieldQuery -> ShowS
$cshowsPrec :: Int -> MoreLikeThisFieldQuery -> ShowS
Show, forall x. Rep MoreLikeThisFieldQuery x -> MoreLikeThisFieldQuery
forall x. MoreLikeThisFieldQuery -> Rep MoreLikeThisFieldQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MoreLikeThisFieldQuery x -> MoreLikeThisFieldQuery
$cfrom :: forall x. MoreLikeThisFieldQuery -> Rep MoreLikeThisFieldQuery x
Generic)
instance ToJSON MoreLikeThisFieldQuery where
toJSON :: MoreLikeThisFieldQuery -> Value
toJSON
( MoreLikeThisFieldQuery
Text
text
(FieldName Text
fieldName)
Maybe PercentMatch
percent
Maybe MinimumTermFrequency
mtf
Maybe MaxQueryTerms
mqt
Maybe (NonEmpty StopWord)
stopwords
Maybe MinDocFrequency
mindf
Maybe MaxDocFrequency
maxdf
Maybe MinWordLength
minwl
Maybe MaxWordLength
maxwl
Maybe BoostTerms
boostTerms
Maybe Boost
boost
Maybe Analyzer
analyzer
) =
[Pair] -> Value
object [Text -> Key
fromText Text
fieldName forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
where
base :: [Pair]
base =
[ Key
"like_text" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
text,
Key
"percent_terms_to_match" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe PercentMatch
percent,
Key
"min_term_freq" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinimumTermFrequency
mtf,
Key
"max_query_terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxQueryTerms
mqt,
Key
"stop_words" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe (NonEmpty StopWord)
stopwords,
Key
"min_doc_freq" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinDocFrequency
mindf,
Key
"max_doc_freq" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxDocFrequency
maxdf,
Key
"min_word_length" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinWordLength
minwl,
Key
"max_word_length" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxWordLength
maxwl,
Key
"boost_terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe BoostTerms
boostTerms,
Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer
]
instance FromJSON MoreLikeThisFieldQuery where
parseJSON :: Value -> Parser MoreLikeThisFieldQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"MoreLikeThisFieldQuery" Object -> Parser MoreLikeThisFieldQuery
parse
where
parse :: Object -> Parser MoreLikeThisFieldQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
Text
-> FieldName
-> Maybe PercentMatch
-> Maybe MinimumTermFrequency
-> Maybe MaxQueryTerms
-> Maybe (NonEmpty StopWord)
-> Maybe MinDocFrequency
-> Maybe MaxDocFrequency
-> Maybe MinWordLength
-> Maybe MaxWordLength
-> Maybe BoostTerms
-> Maybe Boost
-> Maybe Analyzer
-> MoreLikeThisFieldQuery
MoreLikeThisFieldQuery
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"like_text"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure FieldName
fn
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"percent_terms_to_match"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"min_term_freq"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_query_terms"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"stop_words"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"min_doc_freq"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_doc_freq"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"min_word_length"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_word_length"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost_terms"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"
data MoreLikeThisQuery = MoreLikeThisQuery
{ MoreLikeThisQuery -> Text
moreLikeThisText :: Text,
MoreLikeThisQuery -> Maybe (NonEmpty FieldName)
moreLikeThisFields :: Maybe (NonEmpty FieldName),
MoreLikeThisQuery -> Maybe PercentMatch
moreLikeThisPercentMatch :: Maybe PercentMatch,
MoreLikeThisQuery -> Maybe MinimumTermFrequency
moreLikeThisMinimumTermFreq :: Maybe MinimumTermFrequency,
MoreLikeThisQuery -> Maybe MaxQueryTerms
moreLikeThisMaxQueryTerms :: Maybe MaxQueryTerms,
MoreLikeThisQuery -> Maybe (NonEmpty StopWord)
moreLikeThisStopWords :: Maybe (NonEmpty StopWord),
MoreLikeThisQuery -> Maybe MinDocFrequency
moreLikeThisMinDocFrequency :: Maybe MinDocFrequency,
MoreLikeThisQuery -> Maybe MaxDocFrequency
moreLikeThisMaxDocFrequency :: Maybe MaxDocFrequency,
MoreLikeThisQuery -> Maybe MinWordLength
moreLikeThisMinWordLength :: Maybe MinWordLength,
MoreLikeThisQuery -> Maybe MaxWordLength
moreLikeThisMaxWordLength :: Maybe MaxWordLength,
MoreLikeThisQuery -> Maybe BoostTerms
moreLikeThisBoostTerms :: Maybe BoostTerms,
MoreLikeThisQuery -> Maybe Boost
moreLikeThisBoost :: Maybe Boost,
MoreLikeThisQuery -> Maybe Analyzer
moreLikeThisAnalyzer :: Maybe Analyzer
}
deriving (MoreLikeThisQuery -> MoreLikeThisQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MoreLikeThisQuery -> MoreLikeThisQuery -> Bool
$c/= :: MoreLikeThisQuery -> MoreLikeThisQuery -> Bool
== :: MoreLikeThisQuery -> MoreLikeThisQuery -> Bool
$c== :: MoreLikeThisQuery -> MoreLikeThisQuery -> Bool
Eq, Int -> MoreLikeThisQuery -> ShowS
[MoreLikeThisQuery] -> ShowS
MoreLikeThisQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MoreLikeThisQuery] -> ShowS
$cshowList :: [MoreLikeThisQuery] -> ShowS
show :: MoreLikeThisQuery -> String
$cshow :: MoreLikeThisQuery -> String
showsPrec :: Int -> MoreLikeThisQuery -> ShowS
$cshowsPrec :: Int -> MoreLikeThisQuery -> ShowS
Show, forall x. Rep MoreLikeThisQuery x -> MoreLikeThisQuery
forall x. MoreLikeThisQuery -> Rep MoreLikeThisQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MoreLikeThisQuery x -> MoreLikeThisQuery
$cfrom :: forall x. MoreLikeThisQuery -> Rep MoreLikeThisQuery x
Generic)
instance ToJSON MoreLikeThisQuery where
toJSON :: MoreLikeThisQuery -> Value
toJSON
( MoreLikeThisQuery
Text
text
Maybe (NonEmpty FieldName)
fields
Maybe PercentMatch
percent
Maybe MinimumTermFrequency
mtf
Maybe MaxQueryTerms
mqt
Maybe (NonEmpty StopWord)
stopwords
Maybe MinDocFrequency
mindf
Maybe MaxDocFrequency
maxdf
Maybe MinWordLength
minwl
Maybe MaxWordLength
maxwl
Maybe BoostTerms
boostTerms
Maybe Boost
boost
Maybe Analyzer
analyzer
) =
[Pair] -> Value
omitNulls [Pair]
base
where
base :: [Pair]
base =
[ Key
"like_text" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
text,
Key
"fields" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe (NonEmpty FieldName)
fields,
Key
"percent_terms_to_match" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe PercentMatch
percent,
Key
"min_term_freq" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinimumTermFrequency
mtf,
Key
"max_query_terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxQueryTerms
mqt,
Key
"stop_words" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe (NonEmpty StopWord)
stopwords,
Key
"min_doc_freq" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinDocFrequency
mindf,
Key
"max_doc_freq" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxDocFrequency
maxdf,
Key
"min_word_length" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinWordLength
minwl,
Key
"max_word_length" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxWordLength
maxwl,
Key
"boost_terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe BoostTerms
boostTerms,
Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer
]
instance FromJSON MoreLikeThisQuery where
parseJSON :: Value -> Parser MoreLikeThisQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"MoreLikeThisQuery" Object -> Parser MoreLikeThisQuery
parse
where
parse :: Object -> Parser MoreLikeThisQuery
parse Object
o =
Text
-> Maybe (NonEmpty FieldName)
-> Maybe PercentMatch
-> Maybe MinimumTermFrequency
-> Maybe MaxQueryTerms
-> Maybe (NonEmpty StopWord)
-> Maybe MinDocFrequency
-> Maybe MaxDocFrequency
-> Maybe MinWordLength
-> Maybe MaxWordLength
-> Maybe BoostTerms
-> Maybe Boost
-> Maybe Analyzer
-> MoreLikeThisQuery
MoreLikeThisQuery
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"like_text"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fields"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"percent_terms_to_match"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"min_term_freq"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_query_terms"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"stop_words"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"min_doc_freq"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_doc_freq"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"min_word_length"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_word_length"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost_terms"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"
data IndicesQuery = IndicesQuery
{ IndicesQuery -> [IndexName]
indicesQueryIndices :: [IndexName],
IndicesQuery -> Query
indicesQuery :: Query,
IndicesQuery -> Maybe Query
indicesQueryNoMatch :: Maybe Query
}
deriving (IndicesQuery -> IndicesQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IndicesQuery -> IndicesQuery -> Bool
$c/= :: IndicesQuery -> IndicesQuery -> Bool
== :: IndicesQuery -> IndicesQuery -> Bool
$c== :: IndicesQuery -> IndicesQuery -> Bool
Eq, Int -> IndicesQuery -> ShowS
[IndicesQuery] -> ShowS
IndicesQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IndicesQuery] -> ShowS
$cshowList :: [IndicesQuery] -> ShowS
show :: IndicesQuery -> String
$cshow :: IndicesQuery -> String
showsPrec :: Int -> IndicesQuery -> ShowS
$cshowsPrec :: Int -> IndicesQuery -> ShowS
Show, forall x. Rep IndicesQuery x -> IndicesQuery
forall x. IndicesQuery -> Rep IndicesQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep IndicesQuery x -> IndicesQuery
$cfrom :: forall x. IndicesQuery -> Rep IndicesQuery x
Generic)
instance ToJSON IndicesQuery where
toJSON :: IndicesQuery -> Value
toJSON (IndicesQuery [IndexName]
indices Query
query Maybe Query
noMatch) =
[Pair] -> Value
omitNulls
[ Key
"indices" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [IndexName]
indices,
Key
"no_match_query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Query
noMatch,
Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Query
query
]
instance FromJSON IndicesQuery where
parseJSON :: Value -> Parser IndicesQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"IndicesQuery" Object -> Parser IndicesQuery
parse
where
parse :: Object -> Parser IndicesQuery
parse Object
o =
[IndexName] -> Query -> Maybe Query -> IndicesQuery
IndicesQuery
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"indices" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"no_match_query"
data HasParentQuery = HasParentQuery
{ HasParentQuery -> RelationName
hasParentQueryType :: RelationName,
HasParentQuery -> Query
hasParentQuery :: Query,
HasParentQuery -> Maybe AggregateParentScore
hasParentQueryScore :: Maybe AggregateParentScore,
HasParentQuery -> Maybe IgnoreUnmapped
hasParentIgnoreUnmapped :: Maybe IgnoreUnmapped
}
deriving (HasParentQuery -> HasParentQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HasParentQuery -> HasParentQuery -> Bool
$c/= :: HasParentQuery -> HasParentQuery -> Bool
== :: HasParentQuery -> HasParentQuery -> Bool
$c== :: HasParentQuery -> HasParentQuery -> Bool
Eq, Int -> HasParentQuery -> ShowS
[HasParentQuery] -> ShowS
HasParentQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HasParentQuery] -> ShowS
$cshowList :: [HasParentQuery] -> ShowS
show :: HasParentQuery -> String
$cshow :: HasParentQuery -> String
showsPrec :: Int -> HasParentQuery -> ShowS
$cshowsPrec :: Int -> HasParentQuery -> ShowS
Show, forall x. Rep HasParentQuery x -> HasParentQuery
forall x. HasParentQuery -> Rep HasParentQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep HasParentQuery x -> HasParentQuery
$cfrom :: forall x. HasParentQuery -> Rep HasParentQuery x
Generic)
instance ToJSON HasParentQuery where
toJSON :: HasParentQuery -> Value
toJSON (HasParentQuery RelationName
queryType Query
query Maybe AggregateParentScore
scoreType Maybe IgnoreUnmapped
ignoreUnmapped) =
[Pair] -> Value
omitNulls
[ Key
"parent_type" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= RelationName
queryType,
Key
"score" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe AggregateParentScore
scoreType,
Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Query
query,
Key
"ignore_unmapped" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe IgnoreUnmapped
ignoreUnmapped
]
instance FromJSON HasParentQuery where
parseJSON :: Value -> Parser HasParentQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"HasParentQuery" Object -> Parser HasParentQuery
parse
where
parse :: Object -> Parser HasParentQuery
parse Object
o =
RelationName
-> Query
-> Maybe AggregateParentScore
-> Maybe IgnoreUnmapped
-> HasParentQuery
HasParentQuery
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"parent_type"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"score"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"ignore_unmapped"
data HasChildQuery = HasChildQuery
{ HasChildQuery -> RelationName
hasChildQueryType :: RelationName,
HasChildQuery -> Query
hasChildQuery :: Query,
HasChildQuery -> Maybe ScoreType
hasChildQueryScoreType :: Maybe ScoreType,
HasChildQuery -> Maybe IgnoreUnmapped
hasChildIgnoreUnmappped :: Maybe IgnoreUnmapped,
HasChildQuery -> Maybe MinChildren
hasChildMinChildren :: Maybe MinChildren,
HasChildQuery -> Maybe MaxChildren
hasChildMaxChildren :: Maybe MaxChildren
}
deriving (HasChildQuery -> HasChildQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HasChildQuery -> HasChildQuery -> Bool
$c/= :: HasChildQuery -> HasChildQuery -> Bool
== :: HasChildQuery -> HasChildQuery -> Bool
$c== :: HasChildQuery -> HasChildQuery -> Bool
Eq, Int -> HasChildQuery -> ShowS
[HasChildQuery] -> ShowS
HasChildQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HasChildQuery] -> ShowS
$cshowList :: [HasChildQuery] -> ShowS
show :: HasChildQuery -> String
$cshow :: HasChildQuery -> String
showsPrec :: Int -> HasChildQuery -> ShowS
$cshowsPrec :: Int -> HasChildQuery -> ShowS
Show, forall x. Rep HasChildQuery x -> HasChildQuery
forall x. HasChildQuery -> Rep HasChildQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep HasChildQuery x -> HasChildQuery
$cfrom :: forall x. HasChildQuery -> Rep HasChildQuery x
Generic)
instance ToJSON HasChildQuery where
toJSON :: HasChildQuery -> Value
toJSON (HasChildQuery RelationName
queryType Query
query Maybe ScoreType
scoreType Maybe IgnoreUnmapped
ignoreUnmapped Maybe MinChildren
minChildren Maybe MaxChildren
maxChildren) =
[Pair] -> Value
omitNulls
[ Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Query
query,
Key
"score_mode" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe ScoreType
scoreType,
Key
"type" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= RelationName
queryType,
Key
"min_children" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinChildren
minChildren,
Key
"max_children" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxChildren
maxChildren,
Key
"ignore_unmapped" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe IgnoreUnmapped
ignoreUnmapped
]
instance FromJSON HasChildQuery where
parseJSON :: Value -> Parser HasChildQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"HasChildQuery" Object -> Parser HasChildQuery
parse
where
parse :: Object -> Parser HasChildQuery
parse Object
o =
RelationName
-> Query
-> Maybe ScoreType
-> Maybe IgnoreUnmapped
-> Maybe MinChildren
-> Maybe MaxChildren
-> HasChildQuery
HasChildQuery
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"score_mode"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"ignore_unmapped"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"min_children"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_children"
data ScoreType
= ScoreTypeMax
| ScoreTypeSum
| ScoreTypeAvg
| ScoreTypeNone
deriving (ScoreType -> ScoreType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScoreType -> ScoreType -> Bool
$c/= :: ScoreType -> ScoreType -> Bool
== :: ScoreType -> ScoreType -> Bool
$c== :: ScoreType -> ScoreType -> Bool
Eq, Int -> ScoreType -> ShowS
[ScoreType] -> ShowS
ScoreType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScoreType] -> ShowS
$cshowList :: [ScoreType] -> ShowS
show :: ScoreType -> String
$cshow :: ScoreType -> String
showsPrec :: Int -> ScoreType -> ShowS
$cshowsPrec :: Int -> ScoreType -> ShowS
Show, forall x. Rep ScoreType x -> ScoreType
forall x. ScoreType -> Rep ScoreType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ScoreType x -> ScoreType
$cfrom :: forall x. ScoreType -> Rep ScoreType x
Generic)
instance ToJSON ScoreType where
toJSON :: ScoreType -> Value
toJSON ScoreType
ScoreTypeMax = Value
"max"
toJSON ScoreType
ScoreTypeAvg = Value
"avg"
toJSON ScoreType
ScoreTypeSum = Value
"sum"
toJSON ScoreType
ScoreTypeNone = Value
"none"
instance FromJSON ScoreType where
parseJSON :: Value -> Parser ScoreType
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"ScoreType" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f ScoreType
parse
where
parse :: a -> f ScoreType
parse a
"max" = forall (f :: * -> *) a. Applicative f => a -> f a
pure ScoreType
ScoreTypeMax
parse a
"avg" = forall (f :: * -> *) a. Applicative f => a -> f a
pure ScoreType
ScoreTypeAvg
parse a
"sum" = forall (f :: * -> *) a. Applicative f => a -> f a
pure ScoreType
ScoreTypeSum
parse a
"none" = forall (f :: * -> *) a. Applicative f => a -> f a
pure ScoreType
ScoreTypeNone
parse a
t = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unexpected ScoreType: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
t)
data FuzzyQuery = FuzzyQuery
{ FuzzyQuery -> FieldName
fuzzyQueryField :: FieldName,
FuzzyQuery -> Text
fuzzyQueryValue :: Text,
FuzzyQuery -> PrefixLength
fuzzyQueryPrefixLength :: PrefixLength,
FuzzyQuery -> MaxExpansions
fuzzyQueryMaxExpansions :: MaxExpansions,
FuzzyQuery -> Fuzziness
fuzzyQueryFuzziness :: Fuzziness,
FuzzyQuery -> Maybe Boost
fuzzyQueryBoost :: Maybe Boost
}
deriving (FuzzyQuery -> FuzzyQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FuzzyQuery -> FuzzyQuery -> Bool
$c/= :: FuzzyQuery -> FuzzyQuery -> Bool
== :: FuzzyQuery -> FuzzyQuery -> Bool
$c== :: FuzzyQuery -> FuzzyQuery -> Bool
Eq, Int -> FuzzyQuery -> ShowS
[FuzzyQuery] -> ShowS
FuzzyQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FuzzyQuery] -> ShowS
$cshowList :: [FuzzyQuery] -> ShowS
show :: FuzzyQuery -> String
$cshow :: FuzzyQuery -> String
showsPrec :: Int -> FuzzyQuery -> ShowS
$cshowsPrec :: Int -> FuzzyQuery -> ShowS
Show, forall x. Rep FuzzyQuery x -> FuzzyQuery
forall x. FuzzyQuery -> Rep FuzzyQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FuzzyQuery x -> FuzzyQuery
$cfrom :: forall x. FuzzyQuery -> Rep FuzzyQuery x
Generic)
instance ToJSON FuzzyQuery where
toJSON :: FuzzyQuery -> Value
toJSON
( FuzzyQuery
(FieldName Text
fieldName)
Text
queryText
PrefixLength
prefixLength
MaxExpansions
maxEx
Fuzziness
fuzziness
Maybe Boost
boost
) =
[Pair] -> Value
object [Text -> Key
fromText Text
fieldName forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
where
base :: [Pair]
base =
[ Key
"value" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
queryText,
Key
"fuzziness" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Fuzziness
fuzziness,
Key
"prefix_length" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= PrefixLength
prefixLength,
Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
Key
"max_expansions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= MaxExpansions
maxEx
]
instance FromJSON FuzzyQuery where
parseJSON :: Value -> Parser FuzzyQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"FuzzyQuery" Object -> Parser FuzzyQuery
parse
where
parse :: Object -> Parser FuzzyQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
FieldName
-> Text
-> PrefixLength
-> MaxExpansions
-> Fuzziness
-> Maybe Boost
-> FuzzyQuery
FuzzyQuery FieldName
fn
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"prefix_length"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"max_expansions"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"fuzziness"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
data FuzzyLikeFieldQuery = FuzzyLikeFieldQuery
{ FuzzyLikeFieldQuery -> FieldName
fuzzyLikeField :: FieldName,
FuzzyLikeFieldQuery -> Text
fuzzyLikeFieldText :: Text,
FuzzyLikeFieldQuery -> MaxQueryTerms
fuzzyLikeFieldMaxQueryTerms :: MaxQueryTerms,
FuzzyLikeFieldQuery -> IgnoreTermFrequency
fuzzyLikeFieldIgnoreTermFrequency :: IgnoreTermFrequency,
FuzzyLikeFieldQuery -> Fuzziness
fuzzyLikeFieldFuzziness :: Fuzziness,
FuzzyLikeFieldQuery -> PrefixLength
fuzzyLikeFieldPrefixLength :: PrefixLength,
FuzzyLikeFieldQuery -> Boost
fuzzyLikeFieldBoost :: Boost,
FuzzyLikeFieldQuery -> Maybe Analyzer
fuzzyLikeFieldAnalyzer :: Maybe Analyzer
}
deriving (FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
$c/= :: FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
== :: FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
$c== :: FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
Eq, Int -> FuzzyLikeFieldQuery -> ShowS
[FuzzyLikeFieldQuery] -> ShowS
FuzzyLikeFieldQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FuzzyLikeFieldQuery] -> ShowS
$cshowList :: [FuzzyLikeFieldQuery] -> ShowS
show :: FuzzyLikeFieldQuery -> String
$cshow :: FuzzyLikeFieldQuery -> String
showsPrec :: Int -> FuzzyLikeFieldQuery -> ShowS
$cshowsPrec :: Int -> FuzzyLikeFieldQuery -> ShowS
Show, forall x. Rep FuzzyLikeFieldQuery x -> FuzzyLikeFieldQuery
forall x. FuzzyLikeFieldQuery -> Rep FuzzyLikeFieldQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FuzzyLikeFieldQuery x -> FuzzyLikeFieldQuery
$cfrom :: forall x. FuzzyLikeFieldQuery -> Rep FuzzyLikeFieldQuery x
Generic)
instance ToJSON FuzzyLikeFieldQuery where
toJSON :: FuzzyLikeFieldQuery -> Value
toJSON
( FuzzyLikeFieldQuery
(FieldName Text
fieldName)
Text
fieldText
MaxQueryTerms
maxTerms
IgnoreTermFrequency
ignoreFreq
Fuzziness
fuzziness
PrefixLength
prefixLength
Boost
boost
Maybe Analyzer
analyzer
) =
[Pair] -> Value
object
[ Text -> Key
fromText Text
fieldName
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls
[ Key
"like_text" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
fieldText,
Key
"max_query_terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= MaxQueryTerms
maxTerms,
Key
"ignore_tf" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= IgnoreTermFrequency
ignoreFreq,
Key
"fuzziness" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Fuzziness
fuzziness,
Key
"prefix_length" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= PrefixLength
prefixLength,
Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer,
Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Boost
boost
]
]
instance FromJSON FuzzyLikeFieldQuery where
parseJSON :: Value -> Parser FuzzyLikeFieldQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"FuzzyLikeFieldQuery" Object -> Parser FuzzyLikeFieldQuery
parse
where
parse :: Object -> Parser FuzzyLikeFieldQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
FieldName
-> Text
-> MaxQueryTerms
-> IgnoreTermFrequency
-> Fuzziness
-> PrefixLength
-> Boost
-> Maybe Analyzer
-> FuzzyLikeFieldQuery
FuzzyLikeFieldQuery FieldName
fn
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"like_text"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"max_query_terms"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"ignore_tf"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"fuzziness"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"prefix_length"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"boost"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"
data FuzzyLikeThisQuery = FuzzyLikeThisQuery
{ FuzzyLikeThisQuery -> [FieldName]
fuzzyLikeFields :: [FieldName],
FuzzyLikeThisQuery -> Text
fuzzyLikeText :: Text,
FuzzyLikeThisQuery -> MaxQueryTerms
fuzzyLikeMaxQueryTerms :: MaxQueryTerms,
FuzzyLikeThisQuery -> IgnoreTermFrequency
fuzzyLikeIgnoreTermFrequency :: IgnoreTermFrequency,
FuzzyLikeThisQuery -> Fuzziness
fuzzyLikeFuzziness :: Fuzziness,
FuzzyLikeThisQuery -> PrefixLength
fuzzyLikePrefixLength :: PrefixLength,
FuzzyLikeThisQuery -> Boost
fuzzyLikeBoost :: Boost,
FuzzyLikeThisQuery -> Maybe Analyzer
fuzzyLikeAnalyzer :: Maybe Analyzer
}
deriving (FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
$c/= :: FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
== :: FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
$c== :: FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
Eq, Int -> FuzzyLikeThisQuery -> ShowS
[FuzzyLikeThisQuery] -> ShowS
FuzzyLikeThisQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FuzzyLikeThisQuery] -> ShowS
$cshowList :: [FuzzyLikeThisQuery] -> ShowS
show :: FuzzyLikeThisQuery -> String
$cshow :: FuzzyLikeThisQuery -> String
showsPrec :: Int -> FuzzyLikeThisQuery -> ShowS
$cshowsPrec :: Int -> FuzzyLikeThisQuery -> ShowS
Show, forall x. Rep FuzzyLikeThisQuery x -> FuzzyLikeThisQuery
forall x. FuzzyLikeThisQuery -> Rep FuzzyLikeThisQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FuzzyLikeThisQuery x -> FuzzyLikeThisQuery
$cfrom :: forall x. FuzzyLikeThisQuery -> Rep FuzzyLikeThisQuery x
Generic)
instance ToJSON FuzzyLikeThisQuery where
toJSON :: FuzzyLikeThisQuery -> Value
toJSON
( FuzzyLikeThisQuery
[FieldName]
fields
Text
text
MaxQueryTerms
maxTerms
IgnoreTermFrequency
ignoreFreq
Fuzziness
fuzziness
PrefixLength
prefixLength
Boost
boost
Maybe Analyzer
analyzer
) =
[Pair] -> Value
omitNulls [Pair]
base
where
base :: [Pair]
base =
[ Key
"fields" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [FieldName]
fields,
Key
"like_text" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
text,
Key
"max_query_terms" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= MaxQueryTerms
maxTerms,
Key
"ignore_tf" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= IgnoreTermFrequency
ignoreFreq,
Key
"fuzziness" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Fuzziness
fuzziness,
Key
"prefix_length" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= PrefixLength
prefixLength,
Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer,
Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Boost
boost
]
instance FromJSON FuzzyLikeThisQuery where
parseJSON :: Value -> Parser FuzzyLikeThisQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"FuzzyLikeThisQuery" Object -> Parser FuzzyLikeThisQuery
parse
where
parse :: Object -> Parser FuzzyLikeThisQuery
parse Object
o =
[FieldName]
-> Text
-> MaxQueryTerms
-> IgnoreTermFrequency
-> Fuzziness
-> PrefixLength
-> Boost
-> Maybe Analyzer
-> FuzzyLikeThisQuery
FuzzyLikeThisQuery
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fields" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"like_text"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"max_query_terms"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"ignore_tf"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"fuzziness"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"prefix_length"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"boost"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"
data DisMaxQuery = DisMaxQuery
{ DisMaxQuery -> [Query]
disMaxQueries :: [Query],
DisMaxQuery -> Tiebreaker
disMaxTiebreaker :: Tiebreaker,
DisMaxQuery -> Maybe Boost
disMaxBoost :: Maybe Boost
}
deriving (DisMaxQuery -> DisMaxQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DisMaxQuery -> DisMaxQuery -> Bool
$c/= :: DisMaxQuery -> DisMaxQuery -> Bool
== :: DisMaxQuery -> DisMaxQuery -> Bool
$c== :: DisMaxQuery -> DisMaxQuery -> Bool
Eq, Int -> DisMaxQuery -> ShowS
[DisMaxQuery] -> ShowS
DisMaxQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DisMaxQuery] -> ShowS
$cshowList :: [DisMaxQuery] -> ShowS
show :: DisMaxQuery -> String
$cshow :: DisMaxQuery -> String
showsPrec :: Int -> DisMaxQuery -> ShowS
$cshowsPrec :: Int -> DisMaxQuery -> ShowS
Show, forall x. Rep DisMaxQuery x -> DisMaxQuery
forall x. DisMaxQuery -> Rep DisMaxQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DisMaxQuery x -> DisMaxQuery
$cfrom :: forall x. DisMaxQuery -> Rep DisMaxQuery x
Generic)
instance ToJSON DisMaxQuery where
toJSON :: DisMaxQuery -> Value
toJSON (DisMaxQuery [Query]
queries Tiebreaker
tiebreaker Maybe Boost
boost) =
[Pair] -> Value
omitNulls [Pair]
base
where
base :: [Pair]
base =
[ Key
"queries" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Query]
queries,
Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
Key
"tie_breaker" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Tiebreaker
tiebreaker
]
instance FromJSON DisMaxQuery where
parseJSON :: Value -> Parser DisMaxQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"DisMaxQuery" Object -> Parser DisMaxQuery
parse
where
parse :: Object -> Parser DisMaxQuery
parse Object
o =
[Query] -> Tiebreaker -> Maybe Boost -> DisMaxQuery
DisMaxQuery
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"queries" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"tie_breaker"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
data MatchQuery = MatchQuery
{ MatchQuery -> FieldName
matchQueryField :: FieldName,
MatchQuery -> QueryString
matchQueryQueryString :: QueryString,
MatchQuery -> BooleanOperator
matchQueryOperator :: BooleanOperator,
MatchQuery -> ZeroTermsQuery
matchQueryZeroTerms :: ZeroTermsQuery,
MatchQuery -> Maybe CutoffFrequency
matchQueryCutoffFrequency :: Maybe CutoffFrequency,
MatchQuery -> Maybe MatchQueryType
matchQueryMatchType :: Maybe MatchQueryType,
MatchQuery -> Maybe Analyzer
matchQueryAnalyzer :: Maybe Analyzer,
MatchQuery -> Maybe MaxExpansions
matchQueryMaxExpansions :: Maybe MaxExpansions,
MatchQuery -> Maybe Lenient
matchQueryLenient :: Maybe Lenient,
MatchQuery -> Maybe Boost
matchQueryBoost :: Maybe Boost,
MatchQuery -> Maybe Text
matchQueryMinimumShouldMatch :: Maybe Text,
MatchQuery -> Maybe Fuzziness
matchQueryFuzziness :: Maybe Fuzziness
}
deriving (MatchQuery -> MatchQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MatchQuery -> MatchQuery -> Bool
$c/= :: MatchQuery -> MatchQuery -> Bool
== :: MatchQuery -> MatchQuery -> Bool
$c== :: MatchQuery -> MatchQuery -> Bool
Eq, Int -> MatchQuery -> ShowS
[MatchQuery] -> ShowS
MatchQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MatchQuery] -> ShowS
$cshowList :: [MatchQuery] -> ShowS
show :: MatchQuery -> String
$cshow :: MatchQuery -> String
showsPrec :: Int -> MatchQuery -> ShowS
$cshowsPrec :: Int -> MatchQuery -> ShowS
Show, forall x. Rep MatchQuery x -> MatchQuery
forall x. MatchQuery -> Rep MatchQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MatchQuery x -> MatchQuery
$cfrom :: forall x. MatchQuery -> Rep MatchQuery x
Generic)
instance ToJSON MatchQuery where
toJSON :: MatchQuery -> Value
toJSON
( MatchQuery
(FieldName Text
fieldName)
(QueryString Text
mqQueryString)
BooleanOperator
booleanOperator
ZeroTermsQuery
zeroTermsQuery
Maybe CutoffFrequency
cutoffFrequency
Maybe MatchQueryType
matchQueryType
Maybe Analyzer
analyzer
Maybe MaxExpansions
maxExpansions
Maybe Lenient
lenient
Maybe Boost
boost
Maybe Text
minShouldMatch
Maybe Fuzziness
mqFuzziness
) =
[Pair] -> Value
object [Text -> Key
fromText Text
fieldName forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
where
base :: [Pair]
base =
[ Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
mqQueryString,
Key
"operator" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= BooleanOperator
booleanOperator,
Key
"zero_terms_query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= ZeroTermsQuery
zeroTermsQuery,
Key
"cutoff_frequency" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe CutoffFrequency
cutoffFrequency,
Key
"type" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MatchQueryType
matchQueryType,
Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer,
Key
"max_expansions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxExpansions
maxExpansions,
Key
"lenient" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Lenient
lenient,
Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
Key
"minimum_should_match" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Text
minShouldMatch,
Key
"fuzziness" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Fuzziness
mqFuzziness
]
instance FromJSON MatchQuery where
parseJSON :: Value -> Parser MatchQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"MatchQuery" Object -> Parser MatchQuery
parse
where
parse :: Object -> Parser MatchQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
FieldName
-> QueryString
-> BooleanOperator
-> ZeroTermsQuery
-> Maybe CutoffFrequency
-> Maybe MatchQueryType
-> Maybe Analyzer
-> Maybe MaxExpansions
-> Maybe Lenient
-> Maybe Boost
-> Maybe Text
-> Maybe Fuzziness
-> MatchQuery
MatchQuery FieldName
fn
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"operator"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"zero_terms_query"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"cutoff_frequency"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"type"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_expansions"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"lenient"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"minimum_should_match"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fuzziness"
mkMatchQuery :: FieldName -> QueryString -> MatchQuery
mkMatchQuery :: FieldName -> QueryString -> MatchQuery
mkMatchQuery FieldName
field QueryString
query = FieldName
-> QueryString
-> BooleanOperator
-> ZeroTermsQuery
-> Maybe CutoffFrequency
-> Maybe MatchQueryType
-> Maybe Analyzer
-> Maybe MaxExpansions
-> Maybe Lenient
-> Maybe Boost
-> Maybe Text
-> Maybe Fuzziness
-> MatchQuery
MatchQuery FieldName
field QueryString
query BooleanOperator
Or ZeroTermsQuery
ZeroTermsNone forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing
data MatchQueryType
= MatchPhrase
| MatchPhrasePrefix
deriving (MatchQueryType -> MatchQueryType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MatchQueryType -> MatchQueryType -> Bool
$c/= :: MatchQueryType -> MatchQueryType -> Bool
== :: MatchQueryType -> MatchQueryType -> Bool
$c== :: MatchQueryType -> MatchQueryType -> Bool
Eq, Int -> MatchQueryType -> ShowS
[MatchQueryType] -> ShowS
MatchQueryType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MatchQueryType] -> ShowS
$cshowList :: [MatchQueryType] -> ShowS
show :: MatchQueryType -> String
$cshow :: MatchQueryType -> String
showsPrec :: Int -> MatchQueryType -> ShowS
$cshowsPrec :: Int -> MatchQueryType -> ShowS
Show, forall x. Rep MatchQueryType x -> MatchQueryType
forall x. MatchQueryType -> Rep MatchQueryType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MatchQueryType x -> MatchQueryType
$cfrom :: forall x. MatchQueryType -> Rep MatchQueryType x
Generic)
instance ToJSON MatchQueryType where
toJSON :: MatchQueryType -> Value
toJSON MatchQueryType
MatchPhrase = Value
"phrase"
toJSON MatchQueryType
MatchPhrasePrefix = Value
"phrase_prefix"
instance FromJSON MatchQueryType where
parseJSON :: Value -> Parser MatchQueryType
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"MatchQueryType" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f MatchQueryType
parse
where
parse :: a -> f MatchQueryType
parse a
"phrase" = forall (f :: * -> *) a. Applicative f => a -> f a
pure MatchQueryType
MatchPhrase
parse a
"phrase_prefix" = forall (f :: * -> *) a. Applicative f => a -> f a
pure MatchQueryType
MatchPhrasePrefix
parse a
t = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unexpected MatchQueryType: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
t)
data MultiMatchQuery = MultiMatchQuery
{ MultiMatchQuery -> [FieldName]
multiMatchQueryFields :: [FieldName],
MultiMatchQuery -> QueryString
multiMatchQueryString :: QueryString,
MultiMatchQuery -> BooleanOperator
multiMatchQueryOperator :: BooleanOperator,
MultiMatchQuery -> ZeroTermsQuery
multiMatchQueryZeroTerms :: ZeroTermsQuery,
MultiMatchQuery -> Maybe Tiebreaker
multiMatchQueryTiebreaker :: Maybe Tiebreaker,
MultiMatchQuery -> Maybe MultiMatchQueryType
multiMatchQueryType :: Maybe MultiMatchQueryType,
MultiMatchQuery -> Maybe CutoffFrequency
multiMatchQueryCutoffFrequency :: Maybe CutoffFrequency,
MultiMatchQuery -> Maybe Analyzer
multiMatchQueryAnalyzer :: Maybe Analyzer,
MultiMatchQuery -> Maybe MaxExpansions
multiMatchQueryMaxExpansions :: Maybe MaxExpansions,
MultiMatchQuery -> Maybe Lenient
multiMatchQueryLenient :: Maybe Lenient
}
deriving (MultiMatchQuery -> MultiMatchQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MultiMatchQuery -> MultiMatchQuery -> Bool
$c/= :: MultiMatchQuery -> MultiMatchQuery -> Bool
== :: MultiMatchQuery -> MultiMatchQuery -> Bool
$c== :: MultiMatchQuery -> MultiMatchQuery -> Bool
Eq, Int -> MultiMatchQuery -> ShowS
[MultiMatchQuery] -> ShowS
MultiMatchQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MultiMatchQuery] -> ShowS
$cshowList :: [MultiMatchQuery] -> ShowS
show :: MultiMatchQuery -> String
$cshow :: MultiMatchQuery -> String
showsPrec :: Int -> MultiMatchQuery -> ShowS
$cshowsPrec :: Int -> MultiMatchQuery -> ShowS
Show, forall x. Rep MultiMatchQuery x -> MultiMatchQuery
forall x. MultiMatchQuery -> Rep MultiMatchQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MultiMatchQuery x -> MultiMatchQuery
$cfrom :: forall x. MultiMatchQuery -> Rep MultiMatchQuery x
Generic)
instance ToJSON MultiMatchQuery where
toJSON :: MultiMatchQuery -> Value
toJSON
( MultiMatchQuery
[FieldName]
fields
(QueryString Text
query)
BooleanOperator
boolOp
ZeroTermsQuery
ztQ
Maybe Tiebreaker
tb
Maybe MultiMatchQueryType
mmqt
Maybe CutoffFrequency
cf
Maybe Analyzer
analyzer
Maybe MaxExpansions
maxEx
Maybe Lenient
lenient
) =
[Pair] -> Value
object [Key
"multi_match" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
where
base :: [Pair]
base =
[ Key
"fields" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. ToJSON a => a -> Value
toJSON [FieldName]
fields,
Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
query,
Key
"operator" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= BooleanOperator
boolOp,
Key
"zero_terms_query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= ZeroTermsQuery
ztQ,
Key
"tie_breaker" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Tiebreaker
tb,
Key
"type" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MultiMatchQueryType
mmqt,
Key
"cutoff_frequency" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe CutoffFrequency
cf,
Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer,
Key
"max_expansions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MaxExpansions
maxEx,
Key
"lenient" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Lenient
lenient
]
instance FromJSON MultiMatchQuery where
parseJSON :: Value -> Parser MultiMatchQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"MultiMatchQuery" Object -> Parser MultiMatchQuery
parse
where
parse :: Object -> Parser MultiMatchQuery
parse Object
raw = do
Object
o <- Object
raw forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"multi_match"
[FieldName]
-> QueryString
-> BooleanOperator
-> ZeroTermsQuery
-> Maybe Tiebreaker
-> Maybe MultiMatchQueryType
-> Maybe CutoffFrequency
-> Maybe Analyzer
-> Maybe MaxExpansions
-> Maybe Lenient
-> MultiMatchQuery
MultiMatchQuery
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fields" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"operator"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"zero_terms_query"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"tie_breaker"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"type"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"cutoff_frequency"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_expansions"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"lenient"
mkMultiMatchQuery :: [FieldName] -> QueryString -> MultiMatchQuery
mkMultiMatchQuery :: [FieldName] -> QueryString -> MultiMatchQuery
mkMultiMatchQuery [FieldName]
matchFields QueryString
query =
[FieldName]
-> QueryString
-> BooleanOperator
-> ZeroTermsQuery
-> Maybe Tiebreaker
-> Maybe MultiMatchQueryType
-> Maybe CutoffFrequency
-> Maybe Analyzer
-> Maybe MaxExpansions
-> Maybe Lenient
-> MultiMatchQuery
MultiMatchQuery
[FieldName]
matchFields
QueryString
query
BooleanOperator
Or
ZeroTermsQuery
ZeroTermsNone
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
forall a. Maybe a
Nothing
data MultiMatchQueryType
= MultiMatchBestFields
| MultiMatchMostFields
| MultiMatchCrossFields
| MultiMatchPhrase
| MultiMatchPhrasePrefix
deriving (MultiMatchQueryType -> MultiMatchQueryType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MultiMatchQueryType -> MultiMatchQueryType -> Bool
$c/= :: MultiMatchQueryType -> MultiMatchQueryType -> Bool
== :: MultiMatchQueryType -> MultiMatchQueryType -> Bool
$c== :: MultiMatchQueryType -> MultiMatchQueryType -> Bool
Eq, Int -> MultiMatchQueryType -> ShowS
[MultiMatchQueryType] -> ShowS
MultiMatchQueryType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MultiMatchQueryType] -> ShowS
$cshowList :: [MultiMatchQueryType] -> ShowS
show :: MultiMatchQueryType -> String
$cshow :: MultiMatchQueryType -> String
showsPrec :: Int -> MultiMatchQueryType -> ShowS
$cshowsPrec :: Int -> MultiMatchQueryType -> ShowS
Show, forall x. Rep MultiMatchQueryType x -> MultiMatchQueryType
forall x. MultiMatchQueryType -> Rep MultiMatchQueryType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MultiMatchQueryType x -> MultiMatchQueryType
$cfrom :: forall x. MultiMatchQueryType -> Rep MultiMatchQueryType x
Generic)
instance ToJSON MultiMatchQueryType where
toJSON :: MultiMatchQueryType -> Value
toJSON MultiMatchQueryType
MultiMatchBestFields = Value
"best_fields"
toJSON MultiMatchQueryType
MultiMatchMostFields = Value
"most_fields"
toJSON MultiMatchQueryType
MultiMatchCrossFields = Value
"cross_fields"
toJSON MultiMatchQueryType
MultiMatchPhrase = Value
"phrase"
toJSON MultiMatchQueryType
MultiMatchPhrasePrefix = Value
"phrase_prefix"
instance FromJSON MultiMatchQueryType where
parseJSON :: Value -> Parser MultiMatchQueryType
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"MultiMatchPhrasePrefix" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f MultiMatchQueryType
parse
where
parse :: a -> f MultiMatchQueryType
parse a
"best_fields" = forall (f :: * -> *) a. Applicative f => a -> f a
pure MultiMatchQueryType
MultiMatchBestFields
parse a
"most_fields" = forall (f :: * -> *) a. Applicative f => a -> f a
pure MultiMatchQueryType
MultiMatchMostFields
parse a
"cross_fields" = forall (f :: * -> *) a. Applicative f => a -> f a
pure MultiMatchQueryType
MultiMatchCrossFields
parse a
"phrase" = forall (f :: * -> *) a. Applicative f => a -> f a
pure MultiMatchQueryType
MultiMatchPhrase
parse a
"phrase_prefix" = forall (f :: * -> *) a. Applicative f => a -> f a
pure MultiMatchQueryType
MultiMatchPhrasePrefix
parse a
t = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unexpected MultiMatchPhrasePrefix: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
t)
data BoolQuery = BoolQuery
{ BoolQuery -> [Query]
boolQueryMustMatch :: [Query],
BoolQuery -> [Filter]
boolQueryFilter :: [Filter],
BoolQuery -> [Query]
boolQueryMustNotMatch :: [Query],
BoolQuery -> [Query]
boolQueryShouldMatch :: [Query],
BoolQuery -> Maybe MinimumMatch
boolQueryMinimumShouldMatch :: Maybe MinimumMatch,
BoolQuery -> Maybe Boost
boolQueryBoost :: Maybe Boost,
BoolQuery -> Maybe DisableCoord
boolQueryDisableCoord :: Maybe DisableCoord
}
deriving (BoolQuery -> BoolQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BoolQuery -> BoolQuery -> Bool
$c/= :: BoolQuery -> BoolQuery -> Bool
== :: BoolQuery -> BoolQuery -> Bool
$c== :: BoolQuery -> BoolQuery -> Bool
Eq, Int -> BoolQuery -> ShowS
[BoolQuery] -> ShowS
BoolQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BoolQuery] -> ShowS
$cshowList :: [BoolQuery] -> ShowS
show :: BoolQuery -> String
$cshow :: BoolQuery -> String
showsPrec :: Int -> BoolQuery -> ShowS
$cshowsPrec :: Int -> BoolQuery -> ShowS
Show, forall x. Rep BoolQuery x -> BoolQuery
forall x. BoolQuery -> Rep BoolQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BoolQuery x -> BoolQuery
$cfrom :: forall x. BoolQuery -> Rep BoolQuery x
Generic)
instance ToJSON BoolQuery where
toJSON :: BoolQuery -> Value
toJSON (BoolQuery [Query]
mustM [Filter]
filterM' [Query]
notM [Query]
shouldM Maybe MinimumMatch
bqMin Maybe Boost
boost Maybe DisableCoord
disableCoord) =
[Pair] -> Value
omitNulls [Pair]
base
where
base :: [Pair]
base =
[ Key
"must" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Query]
mustM,
Key
"filter" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Filter]
filterM',
Key
"must_not" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Query]
notM,
Key
"should" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Query]
shouldM,
Key
"minimum_should_match" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe MinimumMatch
bqMin,
Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
Key
"disable_coord" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe DisableCoord
disableCoord
]
instance FromJSON BoolQuery where
parseJSON :: Value -> Parser BoolQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"BoolQuery" Object -> Parser BoolQuery
parse
where
parse :: Object -> Parser BoolQuery
parse Object
o =
[Query]
-> [Filter]
-> [Query]
-> [Query]
-> Maybe MinimumMatch
-> Maybe Boost
-> Maybe DisableCoord
-> BoolQuery
BoolQuery
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"must" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"filter" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"must_not" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"should" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"minimum_should_match"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"disable_coord"
mkBoolQuery :: [Query] -> [Filter] -> [Query] -> [Query] -> BoolQuery
mkBoolQuery :: [Query] -> [Filter] -> [Query] -> [Query] -> BoolQuery
mkBoolQuery [Query]
must [Filter]
filt [Query]
mustNot [Query]
should =
[Query]
-> [Filter]
-> [Query]
-> [Query]
-> Maybe MinimumMatch
-> Maybe Boost
-> Maybe DisableCoord
-> BoolQuery
BoolQuery [Query]
must [Filter]
filt [Query]
mustNot [Query]
should forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing
data BoostingQuery = BoostingQuery
{ BoostingQuery -> Query
positiveQuery :: Query,
BoostingQuery -> Query
negativeQuery :: Query,
BoostingQuery -> Boost
negativeBoost :: Boost
}
deriving (BoostingQuery -> BoostingQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BoostingQuery -> BoostingQuery -> Bool
$c/= :: BoostingQuery -> BoostingQuery -> Bool
== :: BoostingQuery -> BoostingQuery -> Bool
$c== :: BoostingQuery -> BoostingQuery -> Bool
Eq, Int -> BoostingQuery -> ShowS
[BoostingQuery] -> ShowS
BoostingQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BoostingQuery] -> ShowS
$cshowList :: [BoostingQuery] -> ShowS
show :: BoostingQuery -> String
$cshow :: BoostingQuery -> String
showsPrec :: Int -> BoostingQuery -> ShowS
$cshowsPrec :: Int -> BoostingQuery -> ShowS
Show, forall x. Rep BoostingQuery x -> BoostingQuery
forall x. BoostingQuery -> Rep BoostingQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BoostingQuery x -> BoostingQuery
$cfrom :: forall x. BoostingQuery -> Rep BoostingQuery x
Generic)
instance ToJSON BoostingQuery where
toJSON :: BoostingQuery -> Value
toJSON (BoostingQuery Query
bqPositiveQuery Query
bqNegativeQuery Boost
bqNegativeBoost) =
[Pair] -> Value
object
[ Key
"positive" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Query
bqPositiveQuery,
Key
"negative" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Query
bqNegativeQuery,
Key
"negative_boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Boost
bqNegativeBoost
]
instance FromJSON BoostingQuery where
parseJSON :: Value -> Parser BoostingQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"BoostingQuery" Object -> Parser BoostingQuery
parse
where
parse :: Object -> Parser BoostingQuery
parse Object
o =
Query -> Query -> Boost -> BoostingQuery
BoostingQuery
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"positive"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"negative"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"negative_boost"
data CommonTermsQuery = CommonTermsQuery
{ CommonTermsQuery -> FieldName
commonField :: FieldName,
CommonTermsQuery -> QueryString
commonQuery :: QueryString,
CommonTermsQuery -> CutoffFrequency
commonCutoffFrequency :: CutoffFrequency,
CommonTermsQuery -> BooleanOperator
commonLowFreqOperator :: BooleanOperator,
CommonTermsQuery -> BooleanOperator
commonHighFreqOperator :: BooleanOperator,
CommonTermsQuery -> Maybe CommonMinimumMatch
commonMinimumShouldMatch :: Maybe CommonMinimumMatch,
CommonTermsQuery -> Maybe Boost
commonBoost :: Maybe Boost,
CommonTermsQuery -> Maybe Analyzer
commonAnalyzer :: Maybe Analyzer,
CommonTermsQuery -> Maybe DisableCoord
commonDisableCoord :: Maybe DisableCoord
}
deriving (CommonTermsQuery -> CommonTermsQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CommonTermsQuery -> CommonTermsQuery -> Bool
$c/= :: CommonTermsQuery -> CommonTermsQuery -> Bool
== :: CommonTermsQuery -> CommonTermsQuery -> Bool
$c== :: CommonTermsQuery -> CommonTermsQuery -> Bool
Eq, Int -> CommonTermsQuery -> ShowS
[CommonTermsQuery] -> ShowS
CommonTermsQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CommonTermsQuery] -> ShowS
$cshowList :: [CommonTermsQuery] -> ShowS
show :: CommonTermsQuery -> String
$cshow :: CommonTermsQuery -> String
showsPrec :: Int -> CommonTermsQuery -> ShowS
$cshowsPrec :: Int -> CommonTermsQuery -> ShowS
Show, forall x. Rep CommonTermsQuery x -> CommonTermsQuery
forall x. CommonTermsQuery -> Rep CommonTermsQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CommonTermsQuery x -> CommonTermsQuery
$cfrom :: forall x. CommonTermsQuery -> Rep CommonTermsQuery x
Generic)
instance ToJSON CommonTermsQuery where
toJSON :: CommonTermsQuery -> Value
toJSON
( CommonTermsQuery
(FieldName Text
fieldName)
(QueryString Text
query)
CutoffFrequency
cf
BooleanOperator
lfo
BooleanOperator
hfo
Maybe CommonMinimumMatch
msm
Maybe Boost
boost
Maybe Analyzer
analyzer
Maybe DisableCoord
disableCoord
) =
[Pair] -> Value
object [Text -> Key
fromText Text
fieldName forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
where
base :: [Pair]
base =
[ Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
query,
Key
"cutoff_frequency" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= CutoffFrequency
cf,
Key
"low_freq_operator" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= BooleanOperator
lfo,
Key
"minimum_should_match" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe CommonMinimumMatch
msm,
Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
Key
"analyzer" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer,
Key
"disable_coord" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe DisableCoord
disableCoord,
Key
"high_freq_operator" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= BooleanOperator
hfo
]
instance FromJSON CommonTermsQuery where
parseJSON :: Value -> Parser CommonTermsQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"CommonTermsQuery" Object -> Parser CommonTermsQuery
parse
where
parse :: Object -> Parser CommonTermsQuery
parse = forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
FieldName
-> QueryString
-> CutoffFrequency
-> BooleanOperator
-> BooleanOperator
-> Maybe CommonMinimumMatch
-> Maybe Boost
-> Maybe Analyzer
-> Maybe DisableCoord
-> CommonTermsQuery
CommonTermsQuery FieldName
fn
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"cutoff_frequency"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"low_freq_operator"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"high_freq_operator"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"minimum_should_match"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"disable_coord"
data CommonMinimumMatch
= CommonMinimumMatchHighLow MinimumMatchHighLow
| CommonMinimumMatch MinimumMatch
deriving (CommonMinimumMatch -> CommonMinimumMatch -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CommonMinimumMatch -> CommonMinimumMatch -> Bool
$c/= :: CommonMinimumMatch -> CommonMinimumMatch -> Bool
== :: CommonMinimumMatch -> CommonMinimumMatch -> Bool
$c== :: CommonMinimumMatch -> CommonMinimumMatch -> Bool
Eq, Int -> CommonMinimumMatch -> ShowS
[CommonMinimumMatch] -> ShowS
CommonMinimumMatch -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CommonMinimumMatch] -> ShowS
$cshowList :: [CommonMinimumMatch] -> ShowS
show :: CommonMinimumMatch -> String
$cshow :: CommonMinimumMatch -> String
showsPrec :: Int -> CommonMinimumMatch -> ShowS
$cshowsPrec :: Int -> CommonMinimumMatch -> ShowS
Show, forall x. Rep CommonMinimumMatch x -> CommonMinimumMatch
forall x. CommonMinimumMatch -> Rep CommonMinimumMatch x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CommonMinimumMatch x -> CommonMinimumMatch
$cfrom :: forall x. CommonMinimumMatch -> Rep CommonMinimumMatch x
Generic)
instance ToJSON CommonMinimumMatch where
toJSON :: CommonMinimumMatch -> Value
toJSON (CommonMinimumMatch MinimumMatch
mm) = forall a. ToJSON a => a -> Value
toJSON MinimumMatch
mm
toJSON (CommonMinimumMatchHighLow (MinimumMatchHighLow MinimumMatch
lowF MinimumMatch
highF)) =
[Pair] -> Value
object
[ Key
"low_freq" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= MinimumMatch
lowF,
Key
"high_freq" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= MinimumMatch
highF
]
instance FromJSON CommonMinimumMatch where
parseJSON :: Value -> Parser CommonMinimumMatch
parseJSON Value
v =
Value -> Parser CommonMinimumMatch
parseMinimum Value
v
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser CommonMinimumMatch
parseMinimumHighLow Value
v
where
parseMinimum :: Value -> Parser CommonMinimumMatch
parseMinimum = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MinimumMatch -> CommonMinimumMatch
CommonMinimumMatch forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. FromJSON a => Value -> Parser a
parseJSON
parseMinimumHighLow :: Value -> Parser CommonMinimumMatch
parseMinimumHighLow =
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MinimumMatchHighLow -> CommonMinimumMatch
CommonMinimumMatchHighLow
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject
String
"CommonMinimumMatchHighLow"
( \Object
o ->
MinimumMatch -> MinimumMatch -> MinimumMatchHighLow
MinimumMatchHighLow
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"low_freq"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"high_freq"
)
data MinimumMatchHighLow = MinimumMatchHighLow
{ MinimumMatchHighLow -> MinimumMatch
lowFreq :: MinimumMatch,
MinimumMatchHighLow -> MinimumMatch
highFreq :: MinimumMatch
}
deriving (MinimumMatchHighLow -> MinimumMatchHighLow -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MinimumMatchHighLow -> MinimumMatchHighLow -> Bool
$c/= :: MinimumMatchHighLow -> MinimumMatchHighLow -> Bool
== :: MinimumMatchHighLow -> MinimumMatchHighLow -> Bool
$c== :: MinimumMatchHighLow -> MinimumMatchHighLow -> Bool
Eq, Int -> MinimumMatchHighLow -> ShowS
[MinimumMatchHighLow] -> ShowS
MinimumMatchHighLow -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MinimumMatchHighLow] -> ShowS
$cshowList :: [MinimumMatchHighLow] -> ShowS
show :: MinimumMatchHighLow -> String
$cshow :: MinimumMatchHighLow -> String
showsPrec :: Int -> MinimumMatchHighLow -> ShowS
$cshowsPrec :: Int -> MinimumMatchHighLow -> ShowS
Show, forall x. Rep MinimumMatchHighLow x -> MinimumMatchHighLow
forall x. MinimumMatchHighLow -> Rep MinimumMatchHighLow x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MinimumMatchHighLow x -> MinimumMatchHighLow
$cfrom :: forall x. MinimumMatchHighLow -> Rep MinimumMatchHighLow x
Generic)
data ZeroTermsQuery
= ZeroTermsNone
| ZeroTermsAll
deriving (ZeroTermsQuery -> ZeroTermsQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ZeroTermsQuery -> ZeroTermsQuery -> Bool
$c/= :: ZeroTermsQuery -> ZeroTermsQuery -> Bool
== :: ZeroTermsQuery -> ZeroTermsQuery -> Bool
$c== :: ZeroTermsQuery -> ZeroTermsQuery -> Bool
Eq, Int -> ZeroTermsQuery -> ShowS
[ZeroTermsQuery] -> ShowS
ZeroTermsQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ZeroTermsQuery] -> ShowS
$cshowList :: [ZeroTermsQuery] -> ShowS
show :: ZeroTermsQuery -> String
$cshow :: ZeroTermsQuery -> String
showsPrec :: Int -> ZeroTermsQuery -> ShowS
$cshowsPrec :: Int -> ZeroTermsQuery -> ShowS
Show, forall x. Rep ZeroTermsQuery x -> ZeroTermsQuery
forall x. ZeroTermsQuery -> Rep ZeroTermsQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ZeroTermsQuery x -> ZeroTermsQuery
$cfrom :: forall x. ZeroTermsQuery -> Rep ZeroTermsQuery x
Generic)
instance ToJSON ZeroTermsQuery where
toJSON :: ZeroTermsQuery -> Value
toJSON ZeroTermsQuery
ZeroTermsNone = Text -> Value
String Text
"none"
toJSON ZeroTermsQuery
ZeroTermsAll = Text -> Value
String Text
"all"
instance FromJSON ZeroTermsQuery where
parseJSON :: Value -> Parser ZeroTermsQuery
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"ZeroTermsQuery" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f ZeroTermsQuery
parse
where
parse :: a -> f ZeroTermsQuery
parse a
"none" = forall (f :: * -> *) a. Applicative f => a -> f a
pure ZeroTermsQuery
ZeroTermsNone
parse a
"all" = forall (f :: * -> *) a. Applicative f => a -> f a
pure ZeroTermsQuery
ZeroTermsAll
parse a
q = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unexpected ZeroTermsQuery: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
q)
data RangeExecution
= RangeExecutionIndex
| RangeExecutionFielddata
deriving (RangeExecution -> RangeExecution -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RangeExecution -> RangeExecution -> Bool
$c/= :: RangeExecution -> RangeExecution -> Bool
== :: RangeExecution -> RangeExecution -> Bool
$c== :: RangeExecution -> RangeExecution -> Bool
Eq, Int -> RangeExecution -> ShowS
[RangeExecution] -> ShowS
RangeExecution -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RangeExecution] -> ShowS
$cshowList :: [RangeExecution] -> ShowS
show :: RangeExecution -> String
$cshow :: RangeExecution -> String
showsPrec :: Int -> RangeExecution -> ShowS
$cshowsPrec :: Int -> RangeExecution -> ShowS
Show, forall x. Rep RangeExecution x -> RangeExecution
forall x. RangeExecution -> Rep RangeExecution x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RangeExecution x -> RangeExecution
$cfrom :: forall x. RangeExecution -> Rep RangeExecution x
Generic)
instance ToJSON RangeExecution where
toJSON :: RangeExecution -> Value
toJSON RangeExecution
RangeExecutionIndex = Value
"index"
toJSON RangeExecution
RangeExecutionFielddata = Value
"fielddata"
instance FromJSON RangeExecution where
parseJSON :: Value -> Parser RangeExecution
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"RangeExecution" forall {a} {f :: * -> *}.
(Eq a, IsString a, Applicative f, Show a) =>
a -> f RangeExecution
parse
where
parse :: a -> f RangeExecution
parse a
"index" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RangeExecution
RangeExecutionIndex
parse a
"fielddata" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RangeExecution
RangeExecutionFielddata
parse a
t = forall a. HasCallStack => String -> a
error (String
"Unrecognized RangeExecution " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
t)
newtype Regexp = Regexp Text deriving (Regexp -> Regexp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Regexp -> Regexp -> Bool
$c/= :: Regexp -> Regexp -> Bool
== :: Regexp -> Regexp -> Bool
$c== :: Regexp -> Regexp -> Bool
Eq, Int -> Regexp -> ShowS
[Regexp] -> ShowS
Regexp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Regexp] -> ShowS
$cshowList :: [Regexp] -> ShowS
show :: Regexp -> String
$cshow :: Regexp -> String
showsPrec :: Int -> Regexp -> ShowS
$cshowsPrec :: Int -> Regexp -> ShowS
Show, forall x. Rep Regexp x -> Regexp
forall x. Regexp -> Rep Regexp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Regexp x -> Regexp
$cfrom :: forall x. Regexp -> Rep Regexp x
Generic, Value -> Parser [Regexp]
Value -> Parser Regexp
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [Regexp]
$cparseJSONList :: Value -> Parser [Regexp]
parseJSON :: Value -> Parser Regexp
$cparseJSON :: Value -> Parser Regexp
FromJSON)
data RegexpFlags
= AllRegexpFlags
| NoRegexpFlags
| SomeRegexpFlags (NonEmpty RegexpFlag)
deriving (RegexpFlags -> RegexpFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegexpFlags -> RegexpFlags -> Bool
$c/= :: RegexpFlags -> RegexpFlags -> Bool
== :: RegexpFlags -> RegexpFlags -> Bool
$c== :: RegexpFlags -> RegexpFlags -> Bool
Eq, Int -> RegexpFlags -> ShowS
[RegexpFlags] -> ShowS
RegexpFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegexpFlags] -> ShowS
$cshowList :: [RegexpFlags] -> ShowS
show :: RegexpFlags -> String
$cshow :: RegexpFlags -> String
showsPrec :: Int -> RegexpFlags -> ShowS
$cshowsPrec :: Int -> RegexpFlags -> ShowS
Show, forall x. Rep RegexpFlags x -> RegexpFlags
forall x. RegexpFlags -> Rep RegexpFlags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RegexpFlags x -> RegexpFlags
$cfrom :: forall x. RegexpFlags -> Rep RegexpFlags x
Generic)
instance ToJSON RegexpFlags where
toJSON :: RegexpFlags -> Value
toJSON RegexpFlags
AllRegexpFlags = Text -> Value
String Text
"ALL"
toJSON RegexpFlags
NoRegexpFlags = Text -> Value
String Text
"NONE"
toJSON (SomeRegexpFlags (RegexpFlag
h :| [RegexpFlag]
fs)) = Text -> Value
String forall a b. (a -> b) -> a -> b
$ Text -> [Text] -> Text
T.intercalate Text
"|" [Text]
flagStrs
where
flagStrs :: [Text]
flagStrs = forall a b. (a -> b) -> [a] -> [b]
map forall {a}. IsString a => RegexpFlag -> a
flagStr forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Eq a => [a] -> [a]
nub forall a b. (a -> b) -> a -> b
$ RegexpFlag
h forall a. a -> [a] -> [a]
: [RegexpFlag]
fs
flagStr :: RegexpFlag -> a
flagStr RegexpFlag
AnyString = a
"ANYSTRING"
flagStr RegexpFlag
Automaton = a
"AUTOMATON"
flagStr RegexpFlag
Complement = a
"COMPLEMENT"
flagStr RegexpFlag
Empty = a
"EMPTY"
flagStr RegexpFlag
Intersection = a
"INTERSECTION"
flagStr RegexpFlag
Interval = a
"INTERVAL"
instance FromJSON RegexpFlags where
parseJSON :: Value -> Parser RegexpFlags
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"RegexpFlags" Text -> Parser RegexpFlags
parse
where
parse :: Text -> Parser RegexpFlags
parse Text
"ALL" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RegexpFlags
AllRegexpFlags
parse Text
"NONE" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RegexpFlags
NoRegexpFlags
parse Text
t = NonEmpty RegexpFlag -> RegexpFlags
SomeRegexpFlags forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => [Value] -> Parser (NonEmpty a)
parseNEJSON (Text -> Value
String forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Text -> [Text]
T.splitOn Text
"|" Text
t)
data RegexpFlag
= AnyString
| Automaton
| Complement
| Empty
| Intersection
| Interval
deriving (RegexpFlag -> RegexpFlag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegexpFlag -> RegexpFlag -> Bool
$c/= :: RegexpFlag -> RegexpFlag -> Bool
== :: RegexpFlag -> RegexpFlag -> Bool
$c== :: RegexpFlag -> RegexpFlag -> Bool
Eq, Int -> RegexpFlag -> ShowS
[RegexpFlag] -> ShowS
RegexpFlag -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegexpFlag] -> ShowS
$cshowList :: [RegexpFlag] -> ShowS
show :: RegexpFlag -> String
$cshow :: RegexpFlag -> String
showsPrec :: Int -> RegexpFlag -> ShowS
$cshowsPrec :: Int -> RegexpFlag -> ShowS
Show, forall x. Rep RegexpFlag x -> RegexpFlag
forall x. RegexpFlag -> Rep RegexpFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RegexpFlag x -> RegexpFlag
$cfrom :: forall x. RegexpFlag -> Rep RegexpFlag x
Generic)
instance FromJSON RegexpFlag where
parseJSON :: Value -> Parser RegexpFlag
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"RegexpFlag" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f RegexpFlag
parse
where
parse :: a -> f RegexpFlag
parse a
"ANYSTRING" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RegexpFlag
AnyString
parse a
"AUTOMATON" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RegexpFlag
Automaton
parse a
"COMPLEMENT" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RegexpFlag
Complement
parse a
"EMPTY" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RegexpFlag
Empty
parse a
"INTERSECTION" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RegexpFlag
Intersection
parse a
"INTERVAL" = forall (f :: * -> *) a. Applicative f => a -> f a
pure RegexpFlag
Interval
parse a
f = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unknown RegexpFlag: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
f)
newtype LessThan = LessThan Double deriving (LessThan -> LessThan -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LessThan -> LessThan -> Bool
$c/= :: LessThan -> LessThan -> Bool
== :: LessThan -> LessThan -> Bool
$c== :: LessThan -> LessThan -> Bool
Eq, Int -> LessThan -> ShowS
[LessThan] -> ShowS
LessThan -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LessThan] -> ShowS
$cshowList :: [LessThan] -> ShowS
show :: LessThan -> String
$cshow :: LessThan -> String
showsPrec :: Int -> LessThan -> ShowS
$cshowsPrec :: Int -> LessThan -> ShowS
Show, forall x. Rep LessThan x -> LessThan
forall x. LessThan -> Rep LessThan x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LessThan x -> LessThan
$cfrom :: forall x. LessThan -> Rep LessThan x
Generic)
newtype LessThanEq = LessThanEq Double deriving (LessThanEq -> LessThanEq -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LessThanEq -> LessThanEq -> Bool
$c/= :: LessThanEq -> LessThanEq -> Bool
== :: LessThanEq -> LessThanEq -> Bool
$c== :: LessThanEq -> LessThanEq -> Bool
Eq, Int -> LessThanEq -> ShowS
[LessThanEq] -> ShowS
LessThanEq -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LessThanEq] -> ShowS
$cshowList :: [LessThanEq] -> ShowS
show :: LessThanEq -> String
$cshow :: LessThanEq -> String
showsPrec :: Int -> LessThanEq -> ShowS
$cshowsPrec :: Int -> LessThanEq -> ShowS
Show, forall x. Rep LessThanEq x -> LessThanEq
forall x. LessThanEq -> Rep LessThanEq x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LessThanEq x -> LessThanEq
$cfrom :: forall x. LessThanEq -> Rep LessThanEq x
Generic)
newtype GreaterThan = GreaterThan Double deriving (GreaterThan -> GreaterThan -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GreaterThan -> GreaterThan -> Bool
$c/= :: GreaterThan -> GreaterThan -> Bool
== :: GreaterThan -> GreaterThan -> Bool
$c== :: GreaterThan -> GreaterThan -> Bool
Eq, Int -> GreaterThan -> ShowS
[GreaterThan] -> ShowS
GreaterThan -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GreaterThan] -> ShowS
$cshowList :: [GreaterThan] -> ShowS
show :: GreaterThan -> String
$cshow :: GreaterThan -> String
showsPrec :: Int -> GreaterThan -> ShowS
$cshowsPrec :: Int -> GreaterThan -> ShowS
Show, forall x. Rep GreaterThan x -> GreaterThan
forall x. GreaterThan -> Rep GreaterThan x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GreaterThan x -> GreaterThan
$cfrom :: forall x. GreaterThan -> Rep GreaterThan x
Generic)
newtype GreaterThanEq = GreaterThanEq Double deriving (GreaterThanEq -> GreaterThanEq -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GreaterThanEq -> GreaterThanEq -> Bool
$c/= :: GreaterThanEq -> GreaterThanEq -> Bool
== :: GreaterThanEq -> GreaterThanEq -> Bool
$c== :: GreaterThanEq -> GreaterThanEq -> Bool
Eq, Int -> GreaterThanEq -> ShowS
[GreaterThanEq] -> ShowS
GreaterThanEq -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GreaterThanEq] -> ShowS
$cshowList :: [GreaterThanEq] -> ShowS
show :: GreaterThanEq -> String
$cshow :: GreaterThanEq -> String
showsPrec :: Int -> GreaterThanEq -> ShowS
$cshowsPrec :: Int -> GreaterThanEq -> ShowS
Show, forall x. Rep GreaterThanEq x -> GreaterThanEq
forall x. GreaterThanEq -> Rep GreaterThanEq x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GreaterThanEq x -> GreaterThanEq
$cfrom :: forall x. GreaterThanEq -> Rep GreaterThanEq x
Generic)
newtype LessThanD = LessThanD UTCTime deriving (LessThanD -> LessThanD -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LessThanD -> LessThanD -> Bool
$c/= :: LessThanD -> LessThanD -> Bool
== :: LessThanD -> LessThanD -> Bool
$c== :: LessThanD -> LessThanD -> Bool
Eq, Int -> LessThanD -> ShowS
[LessThanD] -> ShowS
LessThanD -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LessThanD] -> ShowS
$cshowList :: [LessThanD] -> ShowS
show :: LessThanD -> String
$cshow :: LessThanD -> String
showsPrec :: Int -> LessThanD -> ShowS
$cshowsPrec :: Int -> LessThanD -> ShowS
Show, forall x. Rep LessThanD x -> LessThanD
forall x. LessThanD -> Rep LessThanD x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LessThanD x -> LessThanD
$cfrom :: forall x. LessThanD -> Rep LessThanD x
Generic)
newtype LessThanEqD = LessThanEqD UTCTime deriving (LessThanEqD -> LessThanEqD -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LessThanEqD -> LessThanEqD -> Bool
$c/= :: LessThanEqD -> LessThanEqD -> Bool
== :: LessThanEqD -> LessThanEqD -> Bool
$c== :: LessThanEqD -> LessThanEqD -> Bool
Eq, Int -> LessThanEqD -> ShowS
[LessThanEqD] -> ShowS
LessThanEqD -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LessThanEqD] -> ShowS
$cshowList :: [LessThanEqD] -> ShowS
show :: LessThanEqD -> String
$cshow :: LessThanEqD -> String
showsPrec :: Int -> LessThanEqD -> ShowS
$cshowsPrec :: Int -> LessThanEqD -> ShowS
Show, forall x. Rep LessThanEqD x -> LessThanEqD
forall x. LessThanEqD -> Rep LessThanEqD x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LessThanEqD x -> LessThanEqD
$cfrom :: forall x. LessThanEqD -> Rep LessThanEqD x
Generic)
newtype GreaterThanD = GreaterThanD UTCTime deriving (GreaterThanD -> GreaterThanD -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GreaterThanD -> GreaterThanD -> Bool
$c/= :: GreaterThanD -> GreaterThanD -> Bool
== :: GreaterThanD -> GreaterThanD -> Bool
$c== :: GreaterThanD -> GreaterThanD -> Bool
Eq, Int -> GreaterThanD -> ShowS
[GreaterThanD] -> ShowS
GreaterThanD -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GreaterThanD] -> ShowS
$cshowList :: [GreaterThanD] -> ShowS
show :: GreaterThanD -> String
$cshow :: GreaterThanD -> String
showsPrec :: Int -> GreaterThanD -> ShowS
$cshowsPrec :: Int -> GreaterThanD -> ShowS
Show, forall x. Rep GreaterThanD x -> GreaterThanD
forall x. GreaterThanD -> Rep GreaterThanD x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GreaterThanD x -> GreaterThanD
$cfrom :: forall x. GreaterThanD -> Rep GreaterThanD x
Generic)
newtype GreaterThanEqD = GreaterThanEqD UTCTime deriving (GreaterThanEqD -> GreaterThanEqD -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GreaterThanEqD -> GreaterThanEqD -> Bool
$c/= :: GreaterThanEqD -> GreaterThanEqD -> Bool
== :: GreaterThanEqD -> GreaterThanEqD -> Bool
$c== :: GreaterThanEqD -> GreaterThanEqD -> Bool
Eq, Int -> GreaterThanEqD -> ShowS
[GreaterThanEqD] -> ShowS
GreaterThanEqD -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GreaterThanEqD] -> ShowS
$cshowList :: [GreaterThanEqD] -> ShowS
show :: GreaterThanEqD -> String
$cshow :: GreaterThanEqD -> String
showsPrec :: Int -> GreaterThanEqD -> ShowS
$cshowsPrec :: Int -> GreaterThanEqD -> ShowS
Show, forall x. Rep GreaterThanEqD x -> GreaterThanEqD
forall x. GreaterThanEqD -> Rep GreaterThanEqD x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GreaterThanEqD x -> GreaterThanEqD
$cfrom :: forall x. GreaterThanEqD -> Rep GreaterThanEqD x
Generic)
data RangeValue
= RangeDateLte LessThanEqD
| RangeDateLt LessThanD
| RangeDateGte GreaterThanEqD
| RangeDateGt GreaterThanD
| RangeDateGtLt GreaterThanD LessThanD
| RangeDateGteLte GreaterThanEqD LessThanEqD
| RangeDateGteLt GreaterThanEqD LessThanD
| RangeDateGtLte GreaterThanD LessThanEqD
| RangeDoubleLte LessThanEq
| RangeDoubleLt LessThan
| RangeDoubleGte GreaterThanEq
| RangeDoubleGt GreaterThan
| RangeDoubleGtLt GreaterThan LessThan
| RangeDoubleGteLte GreaterThanEq LessThanEq
| RangeDoubleGteLt GreaterThanEq LessThan
| RangeDoubleGtLte GreaterThan LessThanEq
deriving (RangeValue -> RangeValue -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RangeValue -> RangeValue -> Bool
$c/= :: RangeValue -> RangeValue -> Bool
== :: RangeValue -> RangeValue -> Bool
$c== :: RangeValue -> RangeValue -> Bool
Eq, Int -> RangeValue -> ShowS
[RangeValue] -> ShowS
RangeValue -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RangeValue] -> ShowS
$cshowList :: [RangeValue] -> ShowS
show :: RangeValue -> String
$cshow :: RangeValue -> String
showsPrec :: Int -> RangeValue -> ShowS
$cshowsPrec :: Int -> RangeValue -> ShowS
Show, forall x. Rep RangeValue x -> RangeValue
forall x. RangeValue -> Rep RangeValue x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RangeValue x -> RangeValue
$cfrom :: forall x. RangeValue -> Rep RangeValue x
Generic)
parseRangeValue ::
( FromJSON t4,
FromJSON t3,
FromJSON t2,
FromJSON t1
) =>
(t3 -> t5) ->
(t1 -> t6) ->
(t4 -> t7) ->
(t2 -> t8) ->
(t5 -> t6 -> b) ->
(t7 -> t6 -> b) ->
(t5 -> t8 -> b) ->
(t7 -> t8 -> b) ->
(t5 -> b) ->
(t6 -> b) ->
(t7 -> b) ->
(t8 -> b) ->
Parser b ->
Object ->
Parser b
parseRangeValue :: forall t4 t3 t2 t1 t5 t6 t7 t8 b.
(FromJSON t4, FromJSON t3, FromJSON t2, FromJSON t1) =>
(t3 -> t5)
-> (t1 -> t6)
-> (t4 -> t7)
-> (t2 -> t8)
-> (t5 -> t6 -> b)
-> (t7 -> t6 -> b)
-> (t5 -> t8 -> b)
-> (t7 -> t8 -> b)
-> (t5 -> b)
-> (t6 -> b)
-> (t7 -> b)
-> (t8 -> b)
-> Parser b
-> Object
-> Parser b
parseRangeValue
t3 -> t5
mkGt
t1 -> t6
mkLt
t4 -> t7
mkGte
t2 -> t8
mkLte
t5 -> t6 -> b
fGtLt
t7 -> t6 -> b
fGteLt
t5 -> t8 -> b
fGtLte
t7 -> t8 -> b
fGteLte
t5 -> b
fGt
t6 -> b
fLt
t7 -> b
fGte
t8 -> b
fLte
Parser b
nada
Object
o = do
Maybe t1
lt <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"lt"
Maybe t2
lte <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"lte"
Maybe t3
gt <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"gt"
Maybe t4
gte <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"gte"
case (Maybe t1
lt, Maybe t2
lte, Maybe t3
gt, Maybe t4
gte) of
(Just t1
a, Maybe t2
_, Just t3
b, Maybe t4
_) ->
forall (m :: * -> *) a. Monad m => a -> m a
return (t5 -> t6 -> b
fGtLt (t3 -> t5
mkGt t3
b) (t1 -> t6
mkLt t1
a))
(Just t1
a, Maybe t2
_, Maybe t3
_, Just t4
b) ->
forall (m :: * -> *) a. Monad m => a -> m a
return (t7 -> t6 -> b
fGteLt (t4 -> t7
mkGte t4
b) (t1 -> t6
mkLt t1
a))
(Maybe t1
_, Just t2
a, Just t3
b, Maybe t4
_) ->
forall (m :: * -> *) a. Monad m => a -> m a
return (t5 -> t8 -> b
fGtLte (t3 -> t5
mkGt t3
b) (t2 -> t8
mkLte t2
a))
(Maybe t1
_, Just t2
a, Maybe t3
_, Just t4
b) ->
forall (m :: * -> *) a. Monad m => a -> m a
return (t7 -> t8 -> b
fGteLte (t4 -> t7
mkGte t4
b) (t2 -> t8
mkLte t2
a))
(Maybe t1
_, Maybe t2
_, Just t3
a, Maybe t4
_) ->
forall (m :: * -> *) a. Monad m => a -> m a
return (t5 -> b
fGt (t3 -> t5
mkGt t3
a))
(Just t1
a, Maybe t2
_, Maybe t3
_, Maybe t4
_) ->
forall (m :: * -> *) a. Monad m => a -> m a
return (t6 -> b
fLt (t1 -> t6
mkLt t1
a))
(Maybe t1
_, Maybe t2
_, Maybe t3
_, Just t4
a) ->
forall (m :: * -> *) a. Monad m => a -> m a
return (t7 -> b
fGte (t4 -> t7
mkGte t4
a))
(Maybe t1
_, Just t2
a, Maybe t3
_, Maybe t4
_) ->
forall (m :: * -> *) a. Monad m => a -> m a
return (t8 -> b
fLte (t2 -> t8
mkLte t2
a))
(Maybe t1
Nothing, Maybe t2
Nothing, Maybe t3
Nothing, Maybe t4
Nothing) ->
Parser b
nada
instance FromJSON RangeValue where
parseJSON :: Value -> Parser RangeValue
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"RangeValue" Object -> Parser RangeValue
parse
where
parse :: Object -> Parser RangeValue
parse Object
o =
Object -> Parser RangeValue
parseDate Object
o
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Object -> Parser RangeValue
parseDouble Object
o
parseDate :: Object -> Parser RangeValue
parseDate Object
o =
forall t4 t3 t2 t1 t5 t6 t7 t8 b.
(FromJSON t4, FromJSON t3, FromJSON t2, FromJSON t1) =>
(t3 -> t5)
-> (t1 -> t6)
-> (t4 -> t7)
-> (t2 -> t8)
-> (t5 -> t6 -> b)
-> (t7 -> t6 -> b)
-> (t5 -> t8 -> b)
-> (t7 -> t8 -> b)
-> (t5 -> b)
-> (t6 -> b)
-> (t7 -> b)
-> (t8 -> b)
-> Parser b
-> Object
-> Parser b
parseRangeValue
UTCTime -> GreaterThanD
GreaterThanD
UTCTime -> LessThanD
LessThanD
UTCTime -> GreaterThanEqD
GreaterThanEqD
UTCTime -> LessThanEqD
LessThanEqD
GreaterThanD -> LessThanD -> RangeValue
RangeDateGtLt
GreaterThanEqD -> LessThanD -> RangeValue
RangeDateGteLt
GreaterThanD -> LessThanEqD -> RangeValue
RangeDateGtLte
GreaterThanEqD -> LessThanEqD -> RangeValue
RangeDateGteLte
GreaterThanD -> RangeValue
RangeDateGt
LessThanD -> RangeValue
RangeDateLt
GreaterThanEqD -> RangeValue
RangeDateGte
LessThanEqD -> RangeValue
RangeDateLte
forall (m :: * -> *) a. MonadPlus m => m a
mzero
Object
o
parseDouble :: Object -> Parser RangeValue
parseDouble Object
o =
forall t4 t3 t2 t1 t5 t6 t7 t8 b.
(FromJSON t4, FromJSON t3, FromJSON t2, FromJSON t1) =>
(t3 -> t5)
-> (t1 -> t6)
-> (t4 -> t7)
-> (t2 -> t8)
-> (t5 -> t6 -> b)
-> (t7 -> t6 -> b)
-> (t5 -> t8 -> b)
-> (t7 -> t8 -> b)
-> (t5 -> b)
-> (t6 -> b)
-> (t7 -> b)
-> (t8 -> b)
-> Parser b
-> Object
-> Parser b
parseRangeValue
Double -> GreaterThan
GreaterThan
Double -> LessThan
LessThan
Double -> GreaterThanEq
GreaterThanEq
Double -> LessThanEq
LessThanEq
GreaterThan -> LessThan -> RangeValue
RangeDoubleGtLt
GreaterThanEq -> LessThan -> RangeValue
RangeDoubleGteLt
GreaterThan -> LessThanEq -> RangeValue
RangeDoubleGtLte
GreaterThanEq -> LessThanEq -> RangeValue
RangeDoubleGteLte
GreaterThan -> RangeValue
RangeDoubleGt
LessThan -> RangeValue
RangeDoubleLt
GreaterThanEq -> RangeValue
RangeDoubleGte
LessThanEq -> RangeValue
RangeDoubleLte
forall (m :: * -> *) a. MonadPlus m => m a
mzero
Object
o
rangeValueToPair :: RangeValue -> [Pair]
rangeValueToPair :: RangeValue -> [Pair]
rangeValueToPair RangeValue
rv = case RangeValue
rv of
RangeDateLte (LessThanEqD UTCTime
t) -> [Key
"lte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
t]
RangeDateGte (GreaterThanEqD UTCTime
t) -> [Key
"gte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
t]
RangeDateLt (LessThanD UTCTime
t) -> [Key
"lt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
t]
RangeDateGt (GreaterThanD UTCTime
t) -> [Key
"gt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
t]
RangeDateGteLte (GreaterThanEqD UTCTime
l) (LessThanEqD UTCTime
g) -> [Key
"gte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
l, Key
"lte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
g]
RangeDateGtLte (GreaterThanD UTCTime
l) (LessThanEqD UTCTime
g) -> [Key
"gt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
l, Key
"lte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
g]
RangeDateGteLt (GreaterThanEqD UTCTime
l) (LessThanD UTCTime
g) -> [Key
"gte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
l, Key
"lt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
g]
RangeDateGtLt (GreaterThanD UTCTime
l) (LessThanD UTCTime
g) -> [Key
"gt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
l, Key
"lt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime
g]
RangeDoubleLte (LessThanEq Double
t) -> [Key
"lte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
t]
RangeDoubleGte (GreaterThanEq Double
t) -> [Key
"gte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
t]
RangeDoubleLt (LessThan Double
t) -> [Key
"lt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
t]
RangeDoubleGt (GreaterThan Double
t) -> [Key
"gt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
t]
RangeDoubleGteLte (GreaterThanEq Double
l) (LessThanEq Double
g) -> [Key
"gte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
l, Key
"lte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
g]
RangeDoubleGtLte (GreaterThan Double
l) (LessThanEq Double
g) -> [Key
"gt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
l, Key
"lte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
g]
RangeDoubleGteLt (GreaterThanEq Double
l) (LessThan Double
g) -> [Key
"gte" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
l, Key
"lt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
g]
RangeDoubleGtLt (GreaterThan Double
l) (LessThan Double
g) -> [Key
"gt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
l, Key
"lt" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
g]
data Term = Term
{ Term -> Key
termField :: Key,
Term -> Text
termValue :: Text
}
deriving (Term -> Term -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Term -> Term -> Bool
$c/= :: Term -> Term -> Bool
== :: Term -> Term -> Bool
$c== :: Term -> Term -> Bool
Eq, Int -> Term -> ShowS
[Term] -> ShowS
Term -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Term] -> ShowS
$cshowList :: [Term] -> ShowS
show :: Term -> String
$cshow :: Term -> String
showsPrec :: Int -> Term -> ShowS
$cshowsPrec :: Int -> Term -> ShowS
Show, forall x. Rep Term x -> Term
forall x. Term -> Rep Term x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Term x -> Term
$cfrom :: forall x. Term -> Rep Term x
Generic)
instance ToJSON Term where
toJSON :: Term -> Value
toJSON (Term Key
field Text
value) =
[Pair] -> Value
object
[ Key
"term"
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
[Key
field forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
value]
]
instance FromJSON Term where
parseJSON :: Value -> Parser Term
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Term" Object -> Parser Term
parse
where
parse :: Object -> Parser Term
parse Object
o = do
HashMap Key Value
termObj <- Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"term"
case forall k v. HashMap k v -> [(k, v)]
HM.toList HashMap Key Value
termObj of
[(Key
fn, Value
v)] -> Key -> Text -> Term
Term Key
fn forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
[Pair]
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Expected object with 1 field-named key"
data BoolMatch
= MustMatch Term Cache
| MustNotMatch Term Cache
| ShouldMatch [Term] Cache
deriving (BoolMatch -> BoolMatch -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BoolMatch -> BoolMatch -> Bool
$c/= :: BoolMatch -> BoolMatch -> Bool
== :: BoolMatch -> BoolMatch -> Bool
$c== :: BoolMatch -> BoolMatch -> Bool
Eq, Int -> BoolMatch -> ShowS
[BoolMatch] -> ShowS
BoolMatch -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BoolMatch] -> ShowS
$cshowList :: [BoolMatch] -> ShowS
show :: BoolMatch -> String
$cshow :: BoolMatch -> String
showsPrec :: Int -> BoolMatch -> ShowS
$cshowsPrec :: Int -> BoolMatch -> ShowS
Show, forall x. Rep BoolMatch x -> BoolMatch
forall x. BoolMatch -> Rep BoolMatch x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BoolMatch x -> BoolMatch
$cfrom :: forall x. BoolMatch -> Rep BoolMatch x
Generic)
instance ToJSON BoolMatch where
toJSON :: BoolMatch -> Value
toJSON (MustMatch Term
term Bool
cache) =
[Pair] -> Value
object
[ Key
"must" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Term
term,
Key
"_cache" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool
cache
]
toJSON (MustNotMatch Term
term Bool
cache) =
[Pair] -> Value
object
[ Key
"must_not" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Term
term,
Key
"_cache" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool
cache
]
toJSON (ShouldMatch [Term]
terms Bool
cache) =
[Pair] -> Value
object
[ Key
"should" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. ToJSON a => a -> Value
toJSON [Term]
terms,
Key
"_cache" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool
cache
]
instance FromJSON BoolMatch where
parseJSON :: Value -> Parser BoolMatch
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"BoolMatch" Object -> Parser BoolMatch
parse
where
parse :: Object -> Parser BoolMatch
parse Object
o =
Term -> Parser BoolMatch
mustMatch
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"must"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Term -> Parser BoolMatch
mustNotMatch
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"must_not"
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Term] -> Parser BoolMatch
shouldMatch
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"should"
where
taggedWith :: (a -> Parser b) -> Key -> Parser b
taggedWith a -> Parser b
parser Key
k = a -> Parser b
parser forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
k
mustMatch :: Term -> Parser BoolMatch
mustMatch Term
t = Term -> Bool -> BoolMatch
MustMatch Term
t forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"_cache" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
defaultCache
mustNotMatch :: Term -> Parser BoolMatch
mustNotMatch Term
t = Term -> Bool -> BoolMatch
MustNotMatch Term
t forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"_cache" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
defaultCache
shouldMatch :: [Term] -> Parser BoolMatch
shouldMatch [Term]
t = [Term] -> Bool -> BoolMatch
ShouldMatch [Term]
t forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"_cache" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
defaultCache
data GeoFilterType
= GeoFilterMemory
| GeoFilterIndexed
deriving (GeoFilterType -> GeoFilterType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GeoFilterType -> GeoFilterType -> Bool
$c/= :: GeoFilterType -> GeoFilterType -> Bool
== :: GeoFilterType -> GeoFilterType -> Bool
$c== :: GeoFilterType -> GeoFilterType -> Bool
Eq, Int -> GeoFilterType -> ShowS
[GeoFilterType] -> ShowS
GeoFilterType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GeoFilterType] -> ShowS
$cshowList :: [GeoFilterType] -> ShowS
show :: GeoFilterType -> String
$cshow :: GeoFilterType -> String
showsPrec :: Int -> GeoFilterType -> ShowS
$cshowsPrec :: Int -> GeoFilterType -> ShowS
Show, forall x. Rep GeoFilterType x -> GeoFilterType
forall x. GeoFilterType -> Rep GeoFilterType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GeoFilterType x -> GeoFilterType
$cfrom :: forall x. GeoFilterType -> Rep GeoFilterType x
Generic)
instance ToJSON GeoFilterType where
toJSON :: GeoFilterType -> Value
toJSON GeoFilterType
GeoFilterMemory = Text -> Value
String Text
"memory"
toJSON GeoFilterType
GeoFilterIndexed = Text -> Value
String Text
"indexed"
instance FromJSON GeoFilterType where
parseJSON :: Value -> Parser GeoFilterType
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"GeoFilterType" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f GeoFilterType
parse
where
parse :: a -> f GeoFilterType
parse a
"memory" = forall (f :: * -> *) a. Applicative f => a -> f a
pure GeoFilterType
GeoFilterMemory
parse a
"indexed" = forall (f :: * -> *) a. Applicative f => a -> f a
pure GeoFilterType
GeoFilterIndexed
parse a
t = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unrecognized GeoFilterType: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
t)
data LatLon = LatLon
{ LatLon -> Double
lat :: Double,
LatLon -> Double
lon :: Double
}
deriving (LatLon -> LatLon -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LatLon -> LatLon -> Bool
$c/= :: LatLon -> LatLon -> Bool
== :: LatLon -> LatLon -> Bool
$c== :: LatLon -> LatLon -> Bool
Eq, Int -> LatLon -> ShowS
[LatLon] -> ShowS
LatLon -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LatLon] -> ShowS
$cshowList :: [LatLon] -> ShowS
show :: LatLon -> String
$cshow :: LatLon -> String
showsPrec :: Int -> LatLon -> ShowS
$cshowsPrec :: Int -> LatLon -> ShowS
Show, forall x. Rep LatLon x -> LatLon
forall x. LatLon -> Rep LatLon x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LatLon x -> LatLon
$cfrom :: forall x. LatLon -> Rep LatLon x
Generic)
instance ToJSON LatLon where
toJSON :: LatLon -> Value
toJSON (LatLon Double
lLat Double
lLon) =
[Pair] -> Value
object
[ Key
"lat" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
lLat,
Key
"lon" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Double
lLon
]
instance FromJSON LatLon where
parseJSON :: Value -> Parser LatLon
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"LatLon" Object -> Parser LatLon
parse
where
parse :: Object -> Parser LatLon
parse Object
o =
Double -> Double -> LatLon
LatLon
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"lat"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"lon"
data GeoBoundingBox = GeoBoundingBox
{ GeoBoundingBox -> LatLon
topLeft :: LatLon,
GeoBoundingBox -> LatLon
bottomRight :: LatLon
}
deriving (GeoBoundingBox -> GeoBoundingBox -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GeoBoundingBox -> GeoBoundingBox -> Bool
$c/= :: GeoBoundingBox -> GeoBoundingBox -> Bool
== :: GeoBoundingBox -> GeoBoundingBox -> Bool
$c== :: GeoBoundingBox -> GeoBoundingBox -> Bool
Eq, Int -> GeoBoundingBox -> ShowS
[GeoBoundingBox] -> ShowS
GeoBoundingBox -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GeoBoundingBox] -> ShowS
$cshowList :: [GeoBoundingBox] -> ShowS
show :: GeoBoundingBox -> String
$cshow :: GeoBoundingBox -> String
showsPrec :: Int -> GeoBoundingBox -> ShowS
$cshowsPrec :: Int -> GeoBoundingBox -> ShowS
Show, forall x. Rep GeoBoundingBox x -> GeoBoundingBox
forall x. GeoBoundingBox -> Rep GeoBoundingBox x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GeoBoundingBox x -> GeoBoundingBox
$cfrom :: forall x. GeoBoundingBox -> Rep GeoBoundingBox x
Generic)
instance ToJSON GeoBoundingBox where
toJSON :: GeoBoundingBox -> Value
toJSON (GeoBoundingBox LatLon
gbbTopLeft LatLon
gbbBottomRight) =
[Pair] -> Value
object
[ Key
"top_left" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= LatLon
gbbTopLeft,
Key
"bottom_right" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= LatLon
gbbBottomRight
]
instance FromJSON GeoBoundingBox where
parseJSON :: Value -> Parser GeoBoundingBox
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GeoBoundingBox" Object -> Parser GeoBoundingBox
parse
where
parse :: Object -> Parser GeoBoundingBox
parse Object
o =
LatLon -> LatLon -> GeoBoundingBox
GeoBoundingBox
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"top_left"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"bottom_right"
data GeoBoundingBoxConstraint = GeoBoundingBoxConstraint
{ GeoBoundingBoxConstraint -> FieldName
geoBBField :: FieldName,
GeoBoundingBoxConstraint -> GeoBoundingBox
constraintBox :: GeoBoundingBox,
GeoBoundingBoxConstraint -> Bool
bbConstraintcache :: Cache,
GeoBoundingBoxConstraint -> GeoFilterType
geoType :: GeoFilterType
}
deriving (GeoBoundingBoxConstraint -> GeoBoundingBoxConstraint -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GeoBoundingBoxConstraint -> GeoBoundingBoxConstraint -> Bool
$c/= :: GeoBoundingBoxConstraint -> GeoBoundingBoxConstraint -> Bool
== :: GeoBoundingBoxConstraint -> GeoBoundingBoxConstraint -> Bool
$c== :: GeoBoundingBoxConstraint -> GeoBoundingBoxConstraint -> Bool
Eq, Int -> GeoBoundingBoxConstraint -> ShowS
[GeoBoundingBoxConstraint] -> ShowS
GeoBoundingBoxConstraint -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GeoBoundingBoxConstraint] -> ShowS
$cshowList :: [GeoBoundingBoxConstraint] -> ShowS
show :: GeoBoundingBoxConstraint -> String
$cshow :: GeoBoundingBoxConstraint -> String
showsPrec :: Int -> GeoBoundingBoxConstraint -> ShowS
$cshowsPrec :: Int -> GeoBoundingBoxConstraint -> ShowS
Show, forall x.
Rep GeoBoundingBoxConstraint x -> GeoBoundingBoxConstraint
forall x.
GeoBoundingBoxConstraint -> Rep GeoBoundingBoxConstraint x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GeoBoundingBoxConstraint x -> GeoBoundingBoxConstraint
$cfrom :: forall x.
GeoBoundingBoxConstraint -> Rep GeoBoundingBoxConstraint x
Generic)
instance ToJSON GeoBoundingBoxConstraint where
toJSON :: GeoBoundingBoxConstraint -> Value
toJSON
( GeoBoundingBoxConstraint
(FieldName Text
gbbcGeoBBField)
GeoBoundingBox
gbbcConstraintBox
Bool
cache
GeoFilterType
type'
) =
[Pair] -> Value
object
[ Text -> Key
fromText Text
gbbcGeoBBField forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= GeoBoundingBox
gbbcConstraintBox,
Key
"_cache" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool
cache,
Key
"type" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= GeoFilterType
type'
]
instance FromJSON GeoBoundingBoxConstraint where
parseJSON :: Value -> Parser GeoBoundingBoxConstraint
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GeoBoundingBoxConstraint" Object -> Parser GeoBoundingBoxConstraint
parse
where
parse :: Object -> Parser GeoBoundingBoxConstraint
parse Object
o = case forall v. KeyMap v -> [(Key, v)]
X.toList (forall v. [Key] -> KeyMap v -> KeyMap v
deleteSeveral [Key
"type", Key
"_cache"] Object
o) of
[(Key
fn, Value
v)] ->
FieldName
-> GeoBoundingBox
-> Bool
-> GeoFilterType
-> GeoBoundingBoxConstraint
GeoBoundingBoxConstraint (Text -> FieldName
FieldName forall a b. (a -> b) -> a -> b
$ Key -> Text
toText Key
fn)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"_cache" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
defaultCache
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
[Pair]
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Could not find field name for GeoBoundingBoxConstraint"
data GeoPoint = GeoPoint
{ GeoPoint -> FieldName
geoField :: FieldName,
GeoPoint -> LatLon
latLon :: LatLon
}
deriving (GeoPoint -> GeoPoint -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GeoPoint -> GeoPoint -> Bool
$c/= :: GeoPoint -> GeoPoint -> Bool
== :: GeoPoint -> GeoPoint -> Bool
$c== :: GeoPoint -> GeoPoint -> Bool
Eq, Int -> GeoPoint -> ShowS
[GeoPoint] -> ShowS
GeoPoint -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GeoPoint] -> ShowS
$cshowList :: [GeoPoint] -> ShowS
show :: GeoPoint -> String
$cshow :: GeoPoint -> String
showsPrec :: Int -> GeoPoint -> ShowS
$cshowsPrec :: Int -> GeoPoint -> ShowS
Show, forall x. Rep GeoPoint x -> GeoPoint
forall x. GeoPoint -> Rep GeoPoint x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GeoPoint x -> GeoPoint
$cfrom :: forall x. GeoPoint -> Rep GeoPoint x
Generic)
instance ToJSON GeoPoint where
toJSON :: GeoPoint -> Value
toJSON (GeoPoint (FieldName Text
geoPointField) LatLon
geoPointLatLon) =
[Pair] -> Value
object [Text -> Key
fromText Text
geoPointField forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= LatLon
geoPointLatLon]
data DistanceUnit
= Miles
| Yards
| Feet
| Inches
| Kilometers
| Meters
| Centimeters
| Millimeters
| NauticalMiles
deriving (DistanceUnit -> DistanceUnit -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DistanceUnit -> DistanceUnit -> Bool
$c/= :: DistanceUnit -> DistanceUnit -> Bool
== :: DistanceUnit -> DistanceUnit -> Bool
$c== :: DistanceUnit -> DistanceUnit -> Bool
Eq, Int -> DistanceUnit -> ShowS
[DistanceUnit] -> ShowS
DistanceUnit -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DistanceUnit] -> ShowS
$cshowList :: [DistanceUnit] -> ShowS
show :: DistanceUnit -> String
$cshow :: DistanceUnit -> String
showsPrec :: Int -> DistanceUnit -> ShowS
$cshowsPrec :: Int -> DistanceUnit -> ShowS
Show, forall x. Rep DistanceUnit x -> DistanceUnit
forall x. DistanceUnit -> Rep DistanceUnit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DistanceUnit x -> DistanceUnit
$cfrom :: forall x. DistanceUnit -> Rep DistanceUnit x
Generic)
instance ToJSON DistanceUnit where
toJSON :: DistanceUnit -> Value
toJSON DistanceUnit
Miles = Text -> Value
String Text
"mi"
toJSON DistanceUnit
Yards = Text -> Value
String Text
"yd"
toJSON DistanceUnit
Feet = Text -> Value
String Text
"ft"
toJSON DistanceUnit
Inches = Text -> Value
String Text
"in"
toJSON DistanceUnit
Kilometers = Text -> Value
String Text
"km"
toJSON DistanceUnit
Meters = Text -> Value
String Text
"m"
toJSON DistanceUnit
Centimeters = Text -> Value
String Text
"cm"
toJSON DistanceUnit
Millimeters = Text -> Value
String Text
"mm"
toJSON DistanceUnit
NauticalMiles = Text -> Value
String Text
"nmi"
instance FromJSON DistanceUnit where
parseJSON :: Value -> Parser DistanceUnit
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"DistanceUnit" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f DistanceUnit
parse
where
parse :: a -> f DistanceUnit
parse a
"mi" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
Miles
parse a
"yd" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
Yards
parse a
"ft" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
Feet
parse a
"in" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
Inches
parse a
"km" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
Kilometers
parse a
"m" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
Meters
parse a
"cm" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
Centimeters
parse a
"mm" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
Millimeters
parse a
"nmi" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceUnit
NauticalMiles
parse a
u = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unrecognized DistanceUnit: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
u)
data DistanceType
= Arc
| SloppyArc
| Plane
deriving (DistanceType -> DistanceType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DistanceType -> DistanceType -> Bool
$c/= :: DistanceType -> DistanceType -> Bool
== :: DistanceType -> DistanceType -> Bool
$c== :: DistanceType -> DistanceType -> Bool
Eq, Int -> DistanceType -> ShowS
[DistanceType] -> ShowS
DistanceType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DistanceType] -> ShowS
$cshowList :: [DistanceType] -> ShowS
show :: DistanceType -> String
$cshow :: DistanceType -> String
showsPrec :: Int -> DistanceType -> ShowS
$cshowsPrec :: Int -> DistanceType -> ShowS
Show, forall x. Rep DistanceType x -> DistanceType
forall x. DistanceType -> Rep DistanceType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DistanceType x -> DistanceType
$cfrom :: forall x. DistanceType -> Rep DistanceType x
Generic)
instance ToJSON DistanceType where
toJSON :: DistanceType -> Value
toJSON DistanceType
Arc = Text -> Value
String Text
"arc"
toJSON DistanceType
SloppyArc = Text -> Value
String Text
"sloppy_arc"
toJSON DistanceType
Plane = Text -> Value
String Text
"plane"
instance FromJSON DistanceType where
parseJSON :: Value -> Parser DistanceType
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"DistanceType" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f DistanceType
parse
where
parse :: a -> f DistanceType
parse a
"arc" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceType
Arc
parse a
"sloppy_arc" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceType
SloppyArc
parse a
"plane" = forall (f :: * -> *) a. Applicative f => a -> f a
pure DistanceType
Plane
parse a
t = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unrecognized DistanceType: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
t)
data OptimizeBbox
= OptimizeGeoFilterType GeoFilterType
| NoOptimizeBbox
deriving (OptimizeBbox -> OptimizeBbox -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OptimizeBbox -> OptimizeBbox -> Bool
$c/= :: OptimizeBbox -> OptimizeBbox -> Bool
== :: OptimizeBbox -> OptimizeBbox -> Bool
$c== :: OptimizeBbox -> OptimizeBbox -> Bool
Eq, Int -> OptimizeBbox -> ShowS
[OptimizeBbox] -> ShowS
OptimizeBbox -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OptimizeBbox] -> ShowS
$cshowList :: [OptimizeBbox] -> ShowS
show :: OptimizeBbox -> String
$cshow :: OptimizeBbox -> String
showsPrec :: Int -> OptimizeBbox -> ShowS
$cshowsPrec :: Int -> OptimizeBbox -> ShowS
Show, forall x. Rep OptimizeBbox x -> OptimizeBbox
forall x. OptimizeBbox -> Rep OptimizeBbox x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OptimizeBbox x -> OptimizeBbox
$cfrom :: forall x. OptimizeBbox -> Rep OptimizeBbox x
Generic)
instance ToJSON OptimizeBbox where
toJSON :: OptimizeBbox -> Value
toJSON OptimizeBbox
NoOptimizeBbox = Text -> Value
String Text
"none"
toJSON (OptimizeGeoFilterType GeoFilterType
gft) = forall a. ToJSON a => a -> Value
toJSON GeoFilterType
gft
instance FromJSON OptimizeBbox where
parseJSON :: Value -> Parser OptimizeBbox
parseJSON Value
v =
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"NoOptimizeBbox" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadPlus f) =>
a -> f OptimizeBbox
parseNoOptimize Value
v
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser OptimizeBbox
parseOptimize Value
v
where
parseNoOptimize :: a -> f OptimizeBbox
parseNoOptimize a
"none" = forall (f :: * -> *) a. Applicative f => a -> f a
pure OptimizeBbox
NoOptimizeBbox
parseNoOptimize a
_ = forall (m :: * -> *) a. MonadPlus m => m a
mzero
parseOptimize :: Value -> Parser OptimizeBbox
parseOptimize = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GeoFilterType -> OptimizeBbox
OptimizeGeoFilterType forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. FromJSON a => Value -> Parser a
parseJSON
data Distance = Distance
{ Distance -> Double
coefficient :: Double,
Distance -> DistanceUnit
unit :: DistanceUnit
}
deriving (Distance -> Distance -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Distance -> Distance -> Bool
$c/= :: Distance -> Distance -> Bool
== :: Distance -> Distance -> Bool
$c== :: Distance -> Distance -> Bool
Eq, Int -> Distance -> ShowS
[Distance] -> ShowS
Distance -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Distance] -> ShowS
$cshowList :: [Distance] -> ShowS
show :: Distance -> String
$cshow :: Distance -> String
showsPrec :: Int -> Distance -> ShowS
$cshowsPrec :: Int -> Distance -> ShowS
Show, forall x. Rep Distance x -> Distance
forall x. Distance -> Rep Distance x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Distance x -> Distance
$cfrom :: forall x. Distance -> Rep Distance x
Generic)
instance ToJSON Distance where
toJSON :: Distance -> Value
toJSON (Distance Double
dCoefficient DistanceUnit
dUnit) =
Text -> Value
String Text
boltedTogether
where
coefText :: Text
coefText = forall a. Show a => a -> Text
showText Double
dCoefficient
(String Text
unitText) = forall a. ToJSON a => a -> Value
toJSON DistanceUnit
dUnit
boltedTogether :: Text
boltedTogether = forall a. Monoid a => a -> a -> a
mappend Text
coefText Text
unitText
instance FromJSON Distance where
parseJSON :: Value -> Parser Distance
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"Distance" Text -> Parser Distance
parse
where
parse :: Text -> Parser Distance
parse Text
t =
Double -> DistanceUnit -> Distance
Distance
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {m :: * -> *} {a}. (MonadFail m, Read a) => Text -> m a
parseCoeff Text
nT
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. FromJSON a => Value -> Parser a
parseJSON (Text -> Value
String Text
unitT)
where
(Text
nT, Text
unitT) = (Char -> Bool) -> Text -> (Text, Text)
T.span Char -> Bool
validForNumber Text
t
validForNumber :: Char -> Bool
validForNumber Char
'-' = Bool
True
validForNumber Char
'.' = Bool
True
validForNumber Char
'e' = Bool
True
validForNumber Char
c = Char -> Bool
isNumber Char
c
parseCoeff :: Text -> m a
parseCoeff Text
"" = forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Empty string cannot be parsed as number"
parseCoeff Text
s = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. Read a => String -> a
read (Text -> String
T.unpack Text
s))
data DistanceRange = DistanceRange
{ DistanceRange -> Distance
distanceFrom :: Distance,
DistanceRange -> Distance
distanceTo :: Distance
}
deriving (DistanceRange -> DistanceRange -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DistanceRange -> DistanceRange -> Bool
$c/= :: DistanceRange -> DistanceRange -> Bool
== :: DistanceRange -> DistanceRange -> Bool
$c== :: DistanceRange -> DistanceRange -> Bool
Eq, Int -> DistanceRange -> ShowS
[DistanceRange] -> ShowS
DistanceRange -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DistanceRange] -> ShowS
$cshowList :: [DistanceRange] -> ShowS
show :: DistanceRange -> String
$cshow :: DistanceRange -> String
showsPrec :: Int -> DistanceRange -> ShowS
$cshowsPrec :: Int -> DistanceRange -> ShowS
Show, forall x. Rep DistanceRange x -> DistanceRange
forall x. DistanceRange -> Rep DistanceRange x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DistanceRange x -> DistanceRange
$cfrom :: forall x. DistanceRange -> Rep DistanceRange x
Generic)
type TemplateQueryValue = Text
newtype TemplateQueryKeyValuePairs
= TemplateQueryKeyValuePairs (X.KeyMap TemplateQueryValue)
deriving (TemplateQueryKeyValuePairs -> TemplateQueryKeyValuePairs -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TemplateQueryKeyValuePairs -> TemplateQueryKeyValuePairs -> Bool
$c/= :: TemplateQueryKeyValuePairs -> TemplateQueryKeyValuePairs -> Bool
== :: TemplateQueryKeyValuePairs -> TemplateQueryKeyValuePairs -> Bool
$c== :: TemplateQueryKeyValuePairs -> TemplateQueryKeyValuePairs -> Bool
Eq, Int -> TemplateQueryKeyValuePairs -> ShowS
[TemplateQueryKeyValuePairs] -> ShowS
TemplateQueryKeyValuePairs -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TemplateQueryKeyValuePairs] -> ShowS
$cshowList :: [TemplateQueryKeyValuePairs] -> ShowS
show :: TemplateQueryKeyValuePairs -> String
$cshow :: TemplateQueryKeyValuePairs -> String
showsPrec :: Int -> TemplateQueryKeyValuePairs -> ShowS
$cshowsPrec :: Int -> TemplateQueryKeyValuePairs -> ShowS
Show)
instance ToJSON TemplateQueryKeyValuePairs where
toJSON :: TemplateQueryKeyValuePairs -> Value
toJSON (TemplateQueryKeyValuePairs KeyMap Text
x) = Object -> Value
Object forall a b. (a -> b) -> a -> b
$ Text -> Value
String forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> KeyMap Text
x
instance FromJSON TemplateQueryKeyValuePairs where
parseJSON :: Value -> Parser TemplateQueryKeyValuePairs
parseJSON (Object Object
o) =
forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyMap Text -> TemplateQueryKeyValuePairs
TemplateQueryKeyValuePairs forall a b. (a -> b) -> a -> b
$ forall a b. (a -> Maybe b) -> KeyMap a -> KeyMap b
X.mapMaybe Value -> Maybe Text
getValue Object
o
where
getValue :: Value -> Maybe Text
getValue (String Text
x) = forall a. a -> Maybe a
Just Text
x
getValue Value
_ = forall a. Maybe a
Nothing
parseJSON Value
_ =
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"error parsing TemplateQueryKeyValuePairs"
data BooleanOperator = And | Or deriving (BooleanOperator -> BooleanOperator -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BooleanOperator -> BooleanOperator -> Bool
$c/= :: BooleanOperator -> BooleanOperator -> Bool
== :: BooleanOperator -> BooleanOperator -> Bool
$c== :: BooleanOperator -> BooleanOperator -> Bool
Eq, Int -> BooleanOperator -> ShowS
[BooleanOperator] -> ShowS
BooleanOperator -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BooleanOperator] -> ShowS
$cshowList :: [BooleanOperator] -> ShowS
show :: BooleanOperator -> String
$cshow :: BooleanOperator -> String
showsPrec :: Int -> BooleanOperator -> ShowS
$cshowsPrec :: Int -> BooleanOperator -> ShowS
Show, forall x. Rep BooleanOperator x -> BooleanOperator
forall x. BooleanOperator -> Rep BooleanOperator x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BooleanOperator x -> BooleanOperator
$cfrom :: forall x. BooleanOperator -> Rep BooleanOperator x
Generic)
instance ToJSON BooleanOperator where
toJSON :: BooleanOperator -> Value
toJSON BooleanOperator
And = Text -> Value
String Text
"and"
toJSON BooleanOperator
Or = Text -> Value
String Text
"or"
instance FromJSON BooleanOperator where
parseJSON :: Value -> Parser BooleanOperator
parseJSON = forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"BooleanOperator" forall {a} {f :: * -> *}.
(Eq a, IsString a, MonadFail f, Show a) =>
a -> f BooleanOperator
parse
where
parse :: a -> f BooleanOperator
parse a
"and" = forall (f :: * -> *) a. Applicative f => a -> f a
pure BooleanOperator
And
parse a
"or" = forall (f :: * -> *) a. Applicative f => a -> f a
pure BooleanOperator
Or
parse a
o = forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Unexpected BooleanOperator: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show a
o)
type Cache = Bool
defaultCache :: Cache
defaultCache :: Bool
defaultCache = Bool
False
data FunctionScoreQuery = FunctionScoreQuery
{ FunctionScoreQuery -> Maybe Query
functionScoreQuery :: Maybe Query,
FunctionScoreQuery -> Maybe Boost
functionScoreBoost :: Maybe Boost,
FunctionScoreQuery -> FunctionScoreFunctions
functionScoreFunctions :: FunctionScoreFunctions,
FunctionScoreQuery -> Maybe Boost
functionScoreMaxBoost :: Maybe Boost,
FunctionScoreQuery -> Maybe BoostMode
functionScoreBoostMode :: Maybe BoostMode,
FunctionScoreQuery -> Score
functionScoreMinScore :: Score,
FunctionScoreQuery -> Maybe ScoreMode
functionScoreScoreMode :: Maybe ScoreMode
}
deriving (FunctionScoreQuery -> FunctionScoreQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FunctionScoreQuery -> FunctionScoreQuery -> Bool
$c/= :: FunctionScoreQuery -> FunctionScoreQuery -> Bool
== :: FunctionScoreQuery -> FunctionScoreQuery -> Bool
$c== :: FunctionScoreQuery -> FunctionScoreQuery -> Bool
Eq, Int -> FunctionScoreQuery -> ShowS
[FunctionScoreQuery] -> ShowS
FunctionScoreQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FunctionScoreQuery] -> ShowS
$cshowList :: [FunctionScoreQuery] -> ShowS
show :: FunctionScoreQuery -> String
$cshow :: FunctionScoreQuery -> String
showsPrec :: Int -> FunctionScoreQuery -> ShowS
$cshowsPrec :: Int -> FunctionScoreQuery -> ShowS
Show, forall x. Rep FunctionScoreQuery x -> FunctionScoreQuery
forall x. FunctionScoreQuery -> Rep FunctionScoreQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FunctionScoreQuery x -> FunctionScoreQuery
$cfrom :: forall x. FunctionScoreQuery -> Rep FunctionScoreQuery x
Generic)
instance ToJSON FunctionScoreQuery where
toJSON :: FunctionScoreQuery -> Value
toJSON (FunctionScoreQuery Maybe Query
query Maybe Boost
boost FunctionScoreFunctions
fns Maybe Boost
maxBoost Maybe BoostMode
boostMode Score
minScore Maybe ScoreMode
scoreMode) =
[Pair] -> Value
omitNulls [Pair]
base
where
base :: [Pair]
base =
FunctionScoreFunctions -> Pair
functionScoreFunctionsPair FunctionScoreFunctions
fns
forall a. a -> [a] -> [a]
: [ Key
"query" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Query
query,
Key
"boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
Key
"max_boost" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
maxBoost,
Key
"boost_mode" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe BoostMode
boostMode,
Key
"min_score" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Score
minScore,
Key
"score_mode" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe ScoreMode
scoreMode
]
instance FromJSON FunctionScoreQuery where
parseJSON :: Value -> Parser FunctionScoreQuery
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"FunctionScoreQuery" Object -> Parser FunctionScoreQuery
parse
where
parse :: Object -> Parser FunctionScoreQuery
parse Object
o =
Maybe Query
-> Maybe Boost
-> FunctionScoreFunctions
-> Maybe Boost
-> Maybe BoostMode
-> Score
-> Maybe ScoreMode
-> FunctionScoreQuery
FunctionScoreQuery
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"query"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ( Object -> Parser FunctionScoreFunctions
singleFunction Object
o
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NonEmpty ComponentFunctionScoreFunction
-> Parser FunctionScoreFunctions
multipleFunctions
forall {a} {b}. FromJSON a => (a -> Parser b) -> Key -> Parser b
`taggedWith` Key
"functions"
)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"max_boost"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost_mode"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"min_score"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"score_mode"
where
taggedWith :: (a -> Parser b) -> Key -> Parser b
taggedWith a -> Parser b
parser Key
k = a -> Parser b
parser forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
k
singleFunction :: Object -> Parser FunctionScoreFunctions
singleFunction = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap FunctionScoreFunction -> FunctionScoreFunctions
FunctionScoreSingle forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object -> Parser FunctionScoreFunction
parseFunctionScoreFunction
multipleFunctions :: NonEmpty ComponentFunctionScoreFunction
-> Parser FunctionScoreFunctions
multipleFunctions = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty ComponentFunctionScoreFunction -> FunctionScoreFunctions
FunctionScoreMultiple
data FunctionScoreFunctions
= FunctionScoreSingle FunctionScoreFunction
| FunctionScoreMultiple (NonEmpty ComponentFunctionScoreFunction)
deriving (FunctionScoreFunctions -> FunctionScoreFunctions -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FunctionScoreFunctions -> FunctionScoreFunctions -> Bool
$c/= :: FunctionScoreFunctions -> FunctionScoreFunctions -> Bool
== :: FunctionScoreFunctions -> FunctionScoreFunctions -> Bool
$c== :: FunctionScoreFunctions -> FunctionScoreFunctions -> Bool
Eq, Int -> FunctionScoreFunctions -> ShowS
[FunctionScoreFunctions] -> ShowS
FunctionScoreFunctions -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FunctionScoreFunctions] -> ShowS
$cshowList :: [FunctionScoreFunctions] -> ShowS
show :: FunctionScoreFunctions -> String
$cshow :: FunctionScoreFunctions -> String
showsPrec :: Int -> FunctionScoreFunctions -> ShowS
$cshowsPrec :: Int -> FunctionScoreFunctions -> ShowS
Show, forall x. Rep FunctionScoreFunctions x -> FunctionScoreFunctions
forall x. FunctionScoreFunctions -> Rep FunctionScoreFunctions x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FunctionScoreFunctions x -> FunctionScoreFunctions
$cfrom :: forall x. FunctionScoreFunctions -> Rep FunctionScoreFunctions x
Generic)
data ComponentFunctionScoreFunction = ComponentFunctionScoreFunction
{ ComponentFunctionScoreFunction -> Maybe Filter
componentScoreFunctionFilter :: Maybe Filter,
ComponentFunctionScoreFunction -> FunctionScoreFunction
componentScoreFunction :: FunctionScoreFunction,
ComponentFunctionScoreFunction -> Maybe Weight
componentScoreFunctionWeight :: Maybe Weight
}
deriving (ComponentFunctionScoreFunction
-> ComponentFunctionScoreFunction -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ComponentFunctionScoreFunction
-> ComponentFunctionScoreFunction -> Bool
$c/= :: ComponentFunctionScoreFunction
-> ComponentFunctionScoreFunction -> Bool
== :: ComponentFunctionScoreFunction
-> ComponentFunctionScoreFunction -> Bool
$c== :: ComponentFunctionScoreFunction
-> ComponentFunctionScoreFunction -> Bool
Eq, Int -> ComponentFunctionScoreFunction -> ShowS
[ComponentFunctionScoreFunction] -> ShowS
ComponentFunctionScoreFunction -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ComponentFunctionScoreFunction] -> ShowS
$cshowList :: [ComponentFunctionScoreFunction] -> ShowS
show :: ComponentFunctionScoreFunction -> String
$cshow :: ComponentFunctionScoreFunction -> String
showsPrec :: Int -> ComponentFunctionScoreFunction -> ShowS
$cshowsPrec :: Int -> ComponentFunctionScoreFunction -> ShowS
Show, forall x.
Rep ComponentFunctionScoreFunction x
-> ComponentFunctionScoreFunction
forall x.
ComponentFunctionScoreFunction
-> Rep ComponentFunctionScoreFunction x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ComponentFunctionScoreFunction x
-> ComponentFunctionScoreFunction
$cfrom :: forall x.
ComponentFunctionScoreFunction
-> Rep ComponentFunctionScoreFunction x
Generic)
instance ToJSON ComponentFunctionScoreFunction where
toJSON :: ComponentFunctionScoreFunction -> Value
toJSON (ComponentFunctionScoreFunction Maybe Filter
filter' FunctionScoreFunction
fn Maybe Weight
weight) =
[Pair] -> Value
omitNulls [Pair]
base
where
base :: [Pair]
base =
FunctionScoreFunction -> Pair
functionScoreFunctionPair FunctionScoreFunction
fn
forall a. a -> [a] -> [a]
: [ Key
"filter" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Filter
filter',
Key
"weight" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Weight
weight
]
instance FromJSON ComponentFunctionScoreFunction where
parseJSON :: Value -> Parser ComponentFunctionScoreFunction
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ComponentFunctionScoreFunction" Object -> Parser ComponentFunctionScoreFunction
parse
where
parse :: Object -> Parser ComponentFunctionScoreFunction
parse Object
o =
Maybe Filter
-> FunctionScoreFunction
-> Maybe Weight
-> ComponentFunctionScoreFunction
ComponentFunctionScoreFunction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"filter"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object -> Parser FunctionScoreFunction
parseFunctionScoreFunction Object
o
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"weight"
functionScoreFunctionsPair :: FunctionScoreFunctions -> (Key, Value)
functionScoreFunctionsPair :: FunctionScoreFunctions -> Pair
functionScoreFunctionsPair (FunctionScoreSingle FunctionScoreFunction
fn) =
FunctionScoreFunction -> Pair
functionScoreFunctionPair FunctionScoreFunction
fn
functionScoreFunctionsPair (FunctionScoreMultiple NonEmpty ComponentFunctionScoreFunction
componentFns) =
(Key
"functions", forall a. ToJSON a => a -> Value
toJSON NonEmpty ComponentFunctionScoreFunction
componentFns)
fieldTagged :: (Monad m, MonadFail m) => (FieldName -> Object -> m a) -> Object -> m a
fieldTagged :: forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged FieldName -> Object -> m a
f Object
o = case forall v. KeyMap v -> [(Key, v)]
X.toList Object
o of
[(Key
k, Object Object
o')] -> FieldName -> Object -> m a
f (Text -> FieldName
FieldName forall a b. (a -> b) -> a -> b
$ Key -> Text
toText Key
k) Object
o'
[Pair]
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Expected object with 1 field-named key"
data Fuzziness = Fuzziness Double | FuzzinessAuto
deriving (Fuzziness -> Fuzziness -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Fuzziness -> Fuzziness -> Bool
$c/= :: Fuzziness -> Fuzziness -> Bool
== :: Fuzziness -> Fuzziness -> Bool
$c== :: Fuzziness -> Fuzziness -> Bool
Eq, Int -> Fuzziness -> ShowS
[Fuzziness] -> ShowS
Fuzziness -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Fuzziness] -> ShowS
$cshowList :: [Fuzziness] -> ShowS
show :: Fuzziness -> String
$cshow :: Fuzziness -> String
showsPrec :: Int -> Fuzziness -> ShowS
$cshowsPrec :: Int -> Fuzziness -> ShowS
Show, forall x. Rep Fuzziness x -> Fuzziness
forall x. Fuzziness -> Rep Fuzziness x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Fuzziness x -> Fuzziness
$cfrom :: forall x. Fuzziness -> Rep Fuzziness x
Generic)
instance ToJSON Fuzziness where
toJSON :: Fuzziness -> Value
toJSON (Fuzziness Double
n) = forall a. ToJSON a => a -> Value
toJSON Double
n
toJSON Fuzziness
FuzzinessAuto = Text -> Value
String Text
"AUTO"
instance FromJSON Fuzziness where
parseJSON :: Value -> Parser Fuzziness
parseJSON (String Text
"AUTO") = forall (m :: * -> *) a. Monad m => a -> m a
return Fuzziness
FuzzinessAuto
parseJSON Value
v = Double -> Fuzziness
Fuzziness forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
data InnerHits = InnerHits
{ InnerHits -> Maybe Integer
innerHitsFrom :: Maybe Integer,
InnerHits -> Maybe Integer
innerHitsSize :: Maybe Integer
}
deriving (InnerHits -> InnerHits -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InnerHits -> InnerHits -> Bool
$c/= :: InnerHits -> InnerHits -> Bool
== :: InnerHits -> InnerHits -> Bool
$c== :: InnerHits -> InnerHits -> Bool
Eq, Int -> InnerHits -> ShowS
[InnerHits] -> ShowS
InnerHits -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InnerHits] -> ShowS
$cshowList :: [InnerHits] -> ShowS
show :: InnerHits -> String
$cshow :: InnerHits -> String
showsPrec :: Int -> InnerHits -> ShowS
$cshowsPrec :: Int -> InnerHits -> ShowS
Show, forall x. Rep InnerHits x -> InnerHits
forall x. InnerHits -> Rep InnerHits x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep InnerHits x -> InnerHits
$cfrom :: forall x. InnerHits -> Rep InnerHits x
Generic)
instance ToJSON InnerHits where
toJSON :: InnerHits -> Value
toJSON (InnerHits Maybe Integer
ihFrom Maybe Integer
ihSize) =
[Pair] -> Value
omitNulls
[ Key
"from" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Integer
ihFrom,
Key
"size" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Maybe Integer
ihSize
]
instance FromJSON InnerHits where
parseJSON :: Value -> Parser InnerHits
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"InnerHits" Object -> Parser InnerHits
parse
where
parse :: Object -> Parser InnerHits
parse Object
o =
Maybe Integer -> Maybe Integer -> InnerHits
InnerHits
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"from"
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"size"