module PostgresqlSyntax.Ast.GroupClause where

import qualified HeadedMegaparsec as Parser
import PostgresqlSyntax.Algebra
import PostgresqlSyntax.Ast.GroupByItem
import qualified PostgresqlSyntax.Helpers.Gens as Gens
import qualified PostgresqlSyntax.Helpers.Parsers as Parsers
import qualified PostgresqlSyntax.Helpers.TextBuilders as TextBuilders
import PostgresqlSyntax.Prelude hiding (filter, many, some, try)
import qualified Test.QuickCheck as Qc

-- |
-- ==== References
-- @
-- group_clause:
--   |  GROUP_P BY set_quantifier group_by_list
--   |  /*EMPTY*/
-- @
--
-- @set_quantifier@ (@DISTINCT@\/@ALL@) is not modeled here — this
-- codebase's grammar subset doesn't support @GROUP BY DISTINCT@.
newtype GroupClause = GroupClause (NonEmpty GroupByItem)
  deriving (Int -> GroupClause -> ShowS
[GroupClause] -> ShowS
GroupClause -> String
(Int -> GroupClause -> ShowS)
-> (GroupClause -> String)
-> ([GroupClause] -> ShowS)
-> Show GroupClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GroupClause -> ShowS
showsPrec :: Int -> GroupClause -> ShowS
$cshow :: GroupClause -> String
show :: GroupClause -> String
$cshowList :: [GroupClause] -> ShowS
showList :: [GroupClause] -> ShowS
Show, (forall x. GroupClause -> Rep GroupClause x)
-> (forall x. Rep GroupClause x -> GroupClause)
-> Generic GroupClause
forall x. Rep GroupClause x -> GroupClause
forall x. GroupClause -> Rep GroupClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GroupClause -> Rep GroupClause x
from :: forall x. GroupClause -> Rep GroupClause x
$cto :: forall x. Rep GroupClause x -> GroupClause
to :: forall x. Rep GroupClause x -> GroupClause
Generic, GroupClause -> GroupClause -> Bool
(GroupClause -> GroupClause -> Bool)
-> (GroupClause -> GroupClause -> Bool) -> Eq GroupClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GroupClause -> GroupClause -> Bool
== :: GroupClause -> GroupClause -> Bool
$c/= :: GroupClause -> GroupClause -> Bool
/= :: GroupClause -> GroupClause -> Bool
Eq, Eq GroupClause
Eq GroupClause =>
(GroupClause -> GroupClause -> Ordering)
-> (GroupClause -> GroupClause -> Bool)
-> (GroupClause -> GroupClause -> Bool)
-> (GroupClause -> GroupClause -> Bool)
-> (GroupClause -> GroupClause -> Bool)
-> (GroupClause -> GroupClause -> GroupClause)
-> (GroupClause -> GroupClause -> GroupClause)
-> Ord GroupClause
GroupClause -> GroupClause -> Bool
GroupClause -> GroupClause -> Ordering
GroupClause -> GroupClause -> GroupClause
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: GroupClause -> GroupClause -> Ordering
compare :: GroupClause -> GroupClause -> Ordering
$c< :: GroupClause -> GroupClause -> Bool
< :: GroupClause -> GroupClause -> Bool
$c<= :: GroupClause -> GroupClause -> Bool
<= :: GroupClause -> GroupClause -> Bool
$c> :: GroupClause -> GroupClause -> Bool
> :: GroupClause -> GroupClause -> Bool
$c>= :: GroupClause -> GroupClause -> Bool
>= :: GroupClause -> GroupClause -> Bool
$cmax :: GroupClause -> GroupClause -> GroupClause
max :: GroupClause -> GroupClause -> GroupClause
$cmin :: GroupClause -> GroupClause -> GroupClause
min :: GroupClause -> GroupClause -> GroupClause
Ord, Typeable GroupClause
Typeable GroupClause =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GroupClause -> c GroupClause)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GroupClause)
-> (GroupClause -> Constr)
-> (GroupClause -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GroupClause))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GroupClause))
-> ((forall b. Data b => b -> b) -> GroupClause -> GroupClause)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GroupClause -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GroupClause -> r)
-> (forall u. (forall d. Data d => d -> u) -> GroupClause -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GroupClause -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GroupClause -> m GroupClause)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GroupClause -> m GroupClause)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GroupClause -> m GroupClause)
-> Data GroupClause
GroupClause -> Constr
GroupClause -> DataType
(forall b. Data b => b -> b) -> GroupClause -> GroupClause
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> GroupClause -> u
forall u. (forall d. Data d => d -> u) -> GroupClause -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GroupClause -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GroupClause -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GroupClause -> m GroupClause
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GroupClause -> m GroupClause
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GroupClause
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GroupClause -> c GroupClause
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GroupClause)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GroupClause)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GroupClause -> c GroupClause
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GroupClause -> c GroupClause
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GroupClause
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GroupClause
$ctoConstr :: GroupClause -> Constr
toConstr :: GroupClause -> Constr
$cdataTypeOf :: GroupClause -> DataType
dataTypeOf :: GroupClause -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GroupClause)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GroupClause)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GroupClause)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GroupClause)
$cgmapT :: (forall b. Data b => b -> b) -> GroupClause -> GroupClause
gmapT :: (forall b. Data b => b -> b) -> GroupClause -> GroupClause
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GroupClause -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GroupClause -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GroupClause -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GroupClause -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GroupClause -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GroupClause -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GroupClause -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GroupClause -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GroupClause -> m GroupClause
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GroupClause -> m GroupClause
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GroupClause -> m GroupClause
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GroupClause -> m GroupClause
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GroupClause -> m GroupClause
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GroupClause -> m GroupClause
Data)

instance IsAst GroupClause where
  toTextBuilder :: Settings -> GroupClause -> TextBuilder
toTextBuilder Settings
settings (GroupClause NonEmpty GroupByItem
a) = TextBuilder
"GROUP BY " TextBuilder -> TextBuilder -> TextBuilder
forall a. Semigroup a => a -> a -> a
<> (GroupByItem -> TextBuilder) -> NonEmpty GroupByItem -> TextBuilder
forall a. (a -> TextBuilder) -> NonEmpty a -> TextBuilder
TextBuilders.commaNonEmpty (Settings -> GroupByItem -> TextBuilder
forall a. IsAst a => Settings -> a -> TextBuilder
toTextBuilder Settings
settings) NonEmpty GroupByItem
a
  parser :: Settings -> Parser GroupClause
parser Settings
settings = do
    Text -> HeadedParsec Void Text Text
forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
Parsers.keyphrase Text
"group by"
    HeadedParsec Void Text ()
forall strm err. Stream strm => HeadedParsec err strm ()
Parser.endHead
    HeadedParsec Void Text ()
forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
Parsers.space1
    NonEmpty GroupByItem -> GroupClause
GroupClause (NonEmpty GroupByItem -> GroupClause)
-> HeadedParsec Void Text (NonEmpty GroupByItem)
-> Parser GroupClause
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text ()
-> HeadedParsec Void Text GroupByItem
-> HeadedParsec Void Text (NonEmpty GroupByItem)
forall err strm separtor a.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm separtor
-> HeadedParsec err strm a -> HeadedParsec err strm (NonEmpty a)
Parsers.sep1 HeadedParsec Void Text ()
Parsers.commaSeparator (Settings -> HeadedParsec Void Text GroupByItem
forall a. IsAst a => Settings -> Parser a
parser Settings
settings)

instance Qc.Arbitrary GroupClause where
  shrink :: GroupClause -> [GroupClause]
shrink = GroupClause -> [GroupClause]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
Qc.genericShrink
  arbitrary :: Gen GroupClause
arbitrary = NonEmpty GroupByItem -> GroupClause
GroupClause (NonEmpty GroupByItem -> GroupClause)
-> Gen (NonEmpty GroupByItem) -> Gen GroupClause
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Gen GroupByItem -> Gen (NonEmpty GroupByItem)
forall a. Int -> Gen a -> Gen (NonEmpty a)
Gens.nonEmptyUpTo Int
6 Gen GroupByItem
forall a. Arbitrary a => Gen a
Qc.arbitrary