module PostgresqlSyntax.Ast.QualifiedName where

import qualified HeadedMegaparsec as Parser
import PostgresqlSyntax.Algebra
import PostgresqlSyntax.Ast.Ident
import PostgresqlSyntax.Ast.Indirection
import qualified PostgresqlSyntax.Helpers.Parsers as Parsers
import PostgresqlSyntax.Prelude
import qualified Test.QuickCheck as Qc

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

instance IsAst QualifiedName where
  toTextBuilder :: Settings -> QualifiedName -> TextBuilder
toTextBuilder Settings
settings = \case
    SimpleQualifiedName Ident
a -> Settings -> Ident -> TextBuilder
forall a. IsAst a => Settings -> a -> TextBuilder
toTextBuilder Settings
settings Ident
a
    IndirectedQualifiedName Ident
a Indirection
b -> Settings -> Ident -> TextBuilder
forall a. IsAst a => Settings -> a -> TextBuilder
toTextBuilder Settings
settings Ident
a TextBuilder -> TextBuilder -> TextBuilder
forall a. Semigroup a => a -> a -> a
<> Settings -> Indirection -> TextBuilder
forall a. IsAst a => Settings -> a -> TextBuilder
toTextBuilder Settings
settings Indirection
b
  parser :: Settings -> Parser QualifiedName
parser Settings
settings =
    Ident -> Indirection -> QualifiedName
IndirectedQualifiedName
      (Ident -> Indirection -> QualifiedName)
-> HeadedParsec Void Text Ident
-> HeadedParsec Void Text (Indirection -> QualifiedName)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HeadedParsec Void Text Ident -> HeadedParsec Void Text Ident
forall err strm a.
(Ord err, Stream strm) =>
HeadedParsec err strm a -> HeadedParsec err strm a
Parser.wrapToHead (Settings -> HeadedParsec Void Text Ident
colId Settings
settings)
      HeadedParsec Void Text (Indirection -> QualifiedName)
-> HeadedParsec Void Text Indirection -> Parser QualifiedName
forall a b.
HeadedParsec Void Text (a -> b)
-> HeadedParsec Void Text a -> HeadedParsec Void Text b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (HeadedParsec Void Text ()
forall err strm.
(Ord err, Stream strm, Token strm ~ Char) =>
HeadedParsec err strm ()
Parsers.space HeadedParsec Void Text ()
-> HeadedParsec Void Text Indirection
-> HeadedParsec Void Text Indirection
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
*> Settings -> HeadedParsec Void Text Indirection
forall a. IsAst a => Settings -> Parser a
parser Settings
settings)
        Parser QualifiedName
-> Parser QualifiedName -> Parser QualifiedName
forall a.
HeadedParsec Void Text a
-> HeadedParsec Void Text a -> HeadedParsec Void Text a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Ident -> QualifiedName
SimpleQualifiedName
      (Ident -> QualifiedName)
-> HeadedParsec Void Text Ident -> Parser QualifiedName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Settings -> HeadedParsec Void Text Ident
colId Settings
settings

instance Qc.Arbitrary QualifiedName where
  shrink :: QualifiedName -> [QualifiedName]
shrink = QualifiedName -> [QualifiedName]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
Qc.genericShrink
  arbitrary :: Gen QualifiedName
arbitrary =
    [Gen QualifiedName] -> Gen QualifiedName
forall a. HasCallStack => [Gen a] -> Gen a
Qc.oneof
      [ Ident -> QualifiedName
SimpleQualifiedName (Ident -> QualifiedName) -> Gen Ident -> Gen QualifiedName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Ident
forall a. Arbitrary a => Gen a
Qc.arbitrary,
        Ident -> Indirection -> QualifiedName
IndirectedQualifiedName (Ident -> Indirection -> QualifiedName)
-> Gen Ident -> Gen (Indirection -> QualifiedName)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Ident
forall a. Arbitrary a => Gen a
Qc.arbitrary Gen (Indirection -> QualifiedName)
-> Gen Indirection -> Gen QualifiedName
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Indirection
forall a. Arbitrary a => Gen a
Qc.arbitrary
      ]