module PostgresqlSyntax.Ast.ForLockingItem where

import qualified HeadedMegaparsec as Parser
import PostgresqlSyntax.Algebra
import PostgresqlSyntax.Ast.ForLockingStrength
import PostgresqlSyntax.Ast.QualifiedName
import qualified PostgresqlSyntax.Helpers.Gens as Gens
import qualified PostgresqlSyntax.Helpers.Parsers as Parsers
import qualified PostgresqlSyntax.Helpers.TextBuilders as TextBuilders
import PostgresqlSyntax.Prelude
import qualified Test.QuickCheck as Qc

-- |
-- ==== References
-- @
-- for_locking_item:
--   | for_locking_strength locked_rels_list opt_nowait_or_skip
-- locked_rels_list:
--   | OF qualified_name_list
--   | EMPTY
-- opt_nowait_or_skip:
--   | NOWAIT
--   | SKIP LOCKED
--   | EMPTY
-- @
data ForLockingItem = ForLockingItem ForLockingStrength (Maybe (NonEmpty QualifiedName)) (Maybe Bool)
  deriving (Int -> ForLockingItem -> ShowS
[ForLockingItem] -> ShowS
ForLockingItem -> String
(Int -> ForLockingItem -> ShowS)
-> (ForLockingItem -> String)
-> ([ForLockingItem] -> ShowS)
-> Show ForLockingItem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForLockingItem -> ShowS
showsPrec :: Int -> ForLockingItem -> ShowS
$cshow :: ForLockingItem -> String
show :: ForLockingItem -> String
$cshowList :: [ForLockingItem] -> ShowS
showList :: [ForLockingItem] -> ShowS
Show, (forall x. ForLockingItem -> Rep ForLockingItem x)
-> (forall x. Rep ForLockingItem x -> ForLockingItem)
-> Generic ForLockingItem
forall x. Rep ForLockingItem x -> ForLockingItem
forall x. ForLockingItem -> Rep ForLockingItem x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ForLockingItem -> Rep ForLockingItem x
from :: forall x. ForLockingItem -> Rep ForLockingItem x
$cto :: forall x. Rep ForLockingItem x -> ForLockingItem
to :: forall x. Rep ForLockingItem x -> ForLockingItem
Generic, ForLockingItem -> ForLockingItem -> Bool
(ForLockingItem -> ForLockingItem -> Bool)
-> (ForLockingItem -> ForLockingItem -> Bool) -> Eq ForLockingItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForLockingItem -> ForLockingItem -> Bool
== :: ForLockingItem -> ForLockingItem -> Bool
$c/= :: ForLockingItem -> ForLockingItem -> Bool
/= :: ForLockingItem -> ForLockingItem -> Bool
Eq, Eq ForLockingItem
Eq ForLockingItem =>
(ForLockingItem -> ForLockingItem -> Ordering)
-> (ForLockingItem -> ForLockingItem -> Bool)
-> (ForLockingItem -> ForLockingItem -> Bool)
-> (ForLockingItem -> ForLockingItem -> Bool)
-> (ForLockingItem -> ForLockingItem -> Bool)
-> (ForLockingItem -> ForLockingItem -> ForLockingItem)
-> (ForLockingItem -> ForLockingItem -> ForLockingItem)
-> Ord ForLockingItem
ForLockingItem -> ForLockingItem -> Bool
ForLockingItem -> ForLockingItem -> Ordering
ForLockingItem -> ForLockingItem -> ForLockingItem
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 :: ForLockingItem -> ForLockingItem -> Ordering
compare :: ForLockingItem -> ForLockingItem -> Ordering
$c< :: ForLockingItem -> ForLockingItem -> Bool
< :: ForLockingItem -> ForLockingItem -> Bool
$c<= :: ForLockingItem -> ForLockingItem -> Bool
<= :: ForLockingItem -> ForLockingItem -> Bool
$c> :: ForLockingItem -> ForLockingItem -> Bool
> :: ForLockingItem -> ForLockingItem -> Bool
$c>= :: ForLockingItem -> ForLockingItem -> Bool
>= :: ForLockingItem -> ForLockingItem -> Bool
$cmax :: ForLockingItem -> ForLockingItem -> ForLockingItem
max :: ForLockingItem -> ForLockingItem -> ForLockingItem
$cmin :: ForLockingItem -> ForLockingItem -> ForLockingItem
min :: ForLockingItem -> ForLockingItem -> ForLockingItem
Ord, Typeable ForLockingItem
Typeable ForLockingItem =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ForLockingItem -> c ForLockingItem)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ForLockingItem)
-> (ForLockingItem -> Constr)
-> (ForLockingItem -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ForLockingItem))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ForLockingItem))
-> ((forall b. Data b => b -> b)
    -> ForLockingItem -> ForLockingItem)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ForLockingItem -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ForLockingItem -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ForLockingItem -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ForLockingItem -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ForLockingItem -> m ForLockingItem)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ForLockingItem -> m ForLockingItem)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ForLockingItem -> m ForLockingItem)
-> Data ForLockingItem
ForLockingItem -> Constr
ForLockingItem -> DataType
(forall b. Data b => b -> b) -> ForLockingItem -> ForLockingItem
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) -> ForLockingItem -> u
forall u. (forall d. Data d => d -> u) -> ForLockingItem -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForLockingItem -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForLockingItem -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ForLockingItem -> m ForLockingItem
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForLockingItem -> m ForLockingItem
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForLockingItem
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForLockingItem -> c ForLockingItem
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForLockingItem)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForLockingItem)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForLockingItem -> c ForLockingItem
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForLockingItem -> c ForLockingItem
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForLockingItem
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForLockingItem
$ctoConstr :: ForLockingItem -> Constr
toConstr :: ForLockingItem -> Constr
$cdataTypeOf :: ForLockingItem -> DataType
dataTypeOf :: ForLockingItem -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForLockingItem)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForLockingItem)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForLockingItem)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForLockingItem)
$cgmapT :: (forall b. Data b => b -> b) -> ForLockingItem -> ForLockingItem
gmapT :: (forall b. Data b => b -> b) -> ForLockingItem -> ForLockingItem
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForLockingItem -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForLockingItem -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForLockingItem -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForLockingItem -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ForLockingItem -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ForLockingItem -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ForLockingItem -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ForLockingItem -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ForLockingItem -> m ForLockingItem
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ForLockingItem -> m ForLockingItem
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForLockingItem -> m ForLockingItem
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForLockingItem -> m ForLockingItem
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForLockingItem -> m ForLockingItem
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ForLockingItem -> m ForLockingItem
Data)

instance IsAst ForLockingItem where
  toTextBuilder :: Settings -> ForLockingItem -> TextBuilder
toTextBuilder Settings
settings (ForLockingItem ForLockingStrength
a Maybe (NonEmpty QualifiedName)
b Maybe Bool
c) =
    [Maybe TextBuilder] -> TextBuilder
TextBuilders.optLexemes
      [ TextBuilder -> Maybe TextBuilder
forall a. a -> Maybe a
Just (Settings -> ForLockingStrength -> TextBuilder
forall a. IsAst a => Settings -> a -> TextBuilder
toTextBuilder Settings
settings ForLockingStrength
a),
        (NonEmpty QualifiedName -> TextBuilder)
-> Maybe (NonEmpty QualifiedName) -> Maybe TextBuilder
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NonEmpty QualifiedName -> TextBuilder
lockedRelsList Maybe (NonEmpty QualifiedName)
b,
        (Bool -> TextBuilder) -> Maybe Bool -> Maybe TextBuilder
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> TextBuilder
forall {a}. IsString a => Bool -> a
nowaitOrSkip Maybe Bool
c
      ]
    where
      lockedRelsList :: NonEmpty QualifiedName -> TextBuilder
lockedRelsList NonEmpty QualifiedName
a' = TextBuilder
"OF " TextBuilder -> TextBuilder -> TextBuilder
forall a. Semigroup a => a -> a -> a
<> (QualifiedName -> TextBuilder)
-> NonEmpty QualifiedName -> TextBuilder
forall a. (a -> TextBuilder) -> NonEmpty a -> TextBuilder
TextBuilders.commaNonEmpty (Settings -> QualifiedName -> TextBuilder
forall a. IsAst a => Settings -> a -> TextBuilder
toTextBuilder Settings
settings) NonEmpty QualifiedName
a'
      nowaitOrSkip :: Bool -> a
nowaitOrSkip = a -> a -> Bool -> a
forall a. a -> a -> Bool -> a
bool a
"NOWAIT" a
"SKIP LOCKED"
  parser :: Settings -> Parser ForLockingItem
parser Settings
settings = do
    ForLockingStrength
strength <- Settings -> HeadedParsec Void Text ForLockingStrength
forall a. IsAst a => Settings -> Parser a
parser Settings
settings
    Maybe (NonEmpty QualifiedName)
rels <- HeadedParsec Void Text (NonEmpty QualifiedName)
-> HeadedParsec Void Text (Maybe (NonEmpty QualifiedName))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (HeadedParsec Void Text (NonEmpty QualifiedName)
 -> HeadedParsec Void Text (Maybe (NonEmpty QualifiedName)))
-> HeadedParsec Void Text (NonEmpty QualifiedName)
-> HeadedParsec Void Text (Maybe (NonEmpty QualifiedName))
forall a b. (a -> b) -> a -> b
$ HeadedParsec Void Text ()
forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
Parsers.space1 HeadedParsec Void Text ()
-> HeadedParsec Void Text Text -> HeadedParsec Void Text Text
forall a b.
HeadedParsec Void Text a
-> HeadedParsec Void Text b -> HeadedParsec Void Text b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Text -> HeadedParsec Void Text Text
forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
Parsers.keyword Text
"of" HeadedParsec Void Text Text
-> HeadedParsec Void Text () -> HeadedParsec Void Text ()
forall a b.
HeadedParsec Void Text a
-> HeadedParsec Void Text b -> HeadedParsec Void Text b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text ()
forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
Parsers.space1 HeadedParsec Void Text ()
-> HeadedParsec Void Text () -> HeadedParsec Void Text ()
forall a b.
HeadedParsec Void Text a
-> HeadedParsec Void Text b -> HeadedParsec Void Text b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text ()
forall strm err. Stream strm => HeadedParsec err strm ()
Parser.endHead HeadedParsec Void Text ()
-> HeadedParsec Void Text (NonEmpty QualifiedName)
-> HeadedParsec Void Text (NonEmpty QualifiedName)
forall a b.
HeadedParsec Void Text a
-> HeadedParsec Void Text b -> HeadedParsec Void Text b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text ()
-> HeadedParsec Void Text QualifiedName
-> HeadedParsec Void Text (NonEmpty QualifiedName)
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 QualifiedName
forall a. IsAst a => Settings -> Parser a
parser Settings
settings)
    Maybe Bool
nowaitOrSkip <- HeadedParsec Void Text Bool -> HeadedParsec Void Text (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (HeadedParsec Void Text ()
forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
Parsers.space1 HeadedParsec Void Text ()
-> HeadedParsec Void Text Bool -> HeadedParsec Void Text Bool
forall a b.
HeadedParsec Void Text a
-> HeadedParsec Void Text b -> HeadedParsec Void Text b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> HeadedParsec Void Text Bool
forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
HeadedParsec e s Bool
nowaitOrSkip)
    return (ForLockingStrength
-> Maybe (NonEmpty QualifiedName) -> Maybe Bool -> ForLockingItem
ForLockingItem ForLockingStrength
strength Maybe (NonEmpty QualifiedName)
rels Maybe Bool
nowaitOrSkip)
    where
      nowaitOrSkip :: HeadedParsec e s Bool
nowaitOrSkip = Bool
False Bool -> HeadedParsec e s Text -> HeadedParsec e s Bool
forall a b. a -> HeadedParsec e s b -> HeadedParsec e s a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Text -> HeadedParsec e s Text
forall {s} {e}.
(Tokens s ~ Text, Token s ~ Char, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
Parsers.keyword Text
"nowait" HeadedParsec e s Bool
-> HeadedParsec e s Bool -> HeadedParsec e s Bool
forall a.
HeadedParsec e s a -> HeadedParsec e s a -> HeadedParsec e s a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Bool
True Bool -> HeadedParsec e s Text -> HeadedParsec e s Bool
forall a b. a -> HeadedParsec e s b -> HeadedParsec e s a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Text -> HeadedParsec e s Text
forall {s} {e}.
(Token s ~ Char, Tokens s ~ Text, Ord e, Stream s) =>
Text -> HeadedParsec e s Text
Parsers.keyphrase Text
"skip locked"

instance Qc.Arbitrary ForLockingItem where
  shrink :: ForLockingItem -> [ForLockingItem]
shrink = ForLockingItem -> [ForLockingItem]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
Qc.genericShrink
  arbitrary :: Gen ForLockingItem
arbitrary = ForLockingStrength
-> Maybe (NonEmpty QualifiedName) -> Maybe Bool -> ForLockingItem
ForLockingItem (ForLockingStrength
 -> Maybe (NonEmpty QualifiedName) -> Maybe Bool -> ForLockingItem)
-> Gen ForLockingStrength
-> Gen
     (Maybe (NonEmpty QualifiedName) -> Maybe Bool -> ForLockingItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ForLockingStrength
forall a. Arbitrary a => Gen a
arbitrary Gen
  (Maybe (NonEmpty QualifiedName) -> Maybe Bool -> ForLockingItem)
-> Gen (Maybe (NonEmpty QualifiedName))
-> Gen (Maybe Bool -> ForLockingItem)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (NonEmpty QualifiedName)
-> Gen (Maybe (NonEmpty QualifiedName))
forall a. Gen a -> Gen (Maybe a)
Gens.terminatingMaybe Gen (NonEmpty QualifiedName)
forall a. Arbitrary a => Gen a
arbitrary Gen (Maybe Bool -> ForLockingItem)
-> Gen (Maybe Bool) -> Gen ForLockingItem
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (Maybe Bool)
forall a. Arbitrary a => Gen a
arbitrary