-- | The AST for SQL.
{-# LANGUAGE DeriveDataTypeable #-}
module Language.SQL.SimpleSQL.Syntax
    (-- * Scalar expressions
     ScalarExpr(..)
    ,Name(..)
    ,TypeName(..)
    ,IntervalTypeField(..)
    ,Sign(..)
    ,PrecMultiplier(..)
    ,PrecUnits(..)
    ,SetQuantifier(..)
    ,SortSpec(..)
    ,Direction(..)
    ,NullsOrder(..)
    ,InPredValue(..)
    ,SubQueryExprType(..)
    ,CompPredQuantifier(..)
    ,Frame(..)
    ,FrameRows(..)
    ,FramePos(..)
    ,OdbcLiteralType(..)
     -- * Query expressions
    ,QueryExpr(..)
    ,SetOperatorName(..)
    ,Corresponding(..)
    ,Alias(..)
    ,GroupingExpr(..)
     -- ** From
    ,TableRef(..)
    ,JoinType(..)
    ,JoinCondition(..)
     -- * Statements
    ,Statement(..)
    ,DropBehaviour(..)
    ,IdentityRestart(..)
    ,InsertSource(..)
    ,SetClause(..)
    ,TableElement(..)
    ,ColumnDef(..)
    ,DefaultClause(..)
    ,IdentityWhen(..)
    ,SequenceGeneratorOption(..)
    ,ColConstraintDef(..)
    ,AutoincrementClause
    ,ColConstraint(..)
    ,TableConstraint(..)
    ,ReferenceMatch(..)
    ,ReferentialAction(..)
    ,AlterTableAction(..)
    ,CheckOption(..)
    ,AlterDomainAction(..)
    ,AdminOption(..)
    ,GrantOption(..)
    ,PrivilegeObject(..)
    ,PrivilegeAction(..)
    ,AdminOptionFor(..)
    ,GrantOptionFor(..)
     -- * Comment
    ,Comment(..)

    ,makeSelect
    ,toQueryExpr
    ,MakeSelect(..)
    ) where

import Data.Text (Text)

import Data.Data (Data, Typeable)

-- | Represents a value expression. This is used for the expressions
-- in select lists. It is also used for expressions in where, group
-- by, having, order by and so on.
data ScalarExpr
    = -- | a numeric literal optional decimal point, e+-
      -- integral exponent, e.g
      --
      -- * 10
      --
      -- * 10.
      --
      -- * .1
      --
      -- * 10.1
      --
      -- * 1e5
      --
      -- * 12.34e-6
      NumLit Text
      -- | string literal, with the start and end quote
      -- e.g. 'test' -> TextLit "'" "'" "test"
    | StringLit Text Text Text
      -- | text of interval literal, units of interval precision,
      -- e.g. interval 3 days (3)
    | IntervalLit
      {ScalarExpr -> Maybe Sign
ilSign :: Maybe Sign -- ^ if + or - used
      ,ScalarExpr -> Text
ilLiteral :: Text -- ^ literal text
      ,ScalarExpr -> IntervalTypeField
ilFrom :: IntervalTypeField
      ,ScalarExpr -> Maybe IntervalTypeField
ilTo :: Maybe IntervalTypeField
      }

      -- | prefix 'typed literal', e.g. int '42'
    | TypedLit TypeName Text

      -- | identifier with parts separated by dots
    | Iden [Name]
      -- | star, as in select *, t.*, count(*)
    | Star

    | Parameter -- ^ Represents a ? in a parameterized query
    | PositionalArg Int -- ^ Represents an e.g. $1 in a parameterized query
    | HostParameter Text (Maybe Text) -- ^ represents a host
                                          -- parameter, e.g. :a. The
                                          -- Maybe Text is for the
                                          -- indicator, e.g. :var
                                          -- indicator :nl


      -- | Infix binary operators. This is used for symbol operators
      -- (a + b), keyword operators (a and b) and multiple keyword
      -- operators (a is similar to b)
    | BinOp ScalarExpr [Name] ScalarExpr
      -- | Prefix unary operators. This is used for symbol
      -- operators, keyword operators and multiple keyword operators.
    | PrefixOp [Name] ScalarExpr
      -- | Postfix unary operators. This is used for symbol
      -- operators, keyword operators and multiple keyword operators.
    | PostfixOp [Name] ScalarExpr
      -- | Used for ternary, mixfix and other non orthodox
      -- operators. Currently used for row constructors, and for
      -- between.
    | SpecialOp [Name] [ScalarExpr]

      -- | function application (anything that looks like c style
      -- function application syntactically)
    | App [Name] [ScalarExpr]


      -- | aggregate application, which adds distinct or all, and
      -- order by, to regular function application
    | AggregateApp
      {ScalarExpr -> [Name]
aggName :: [Name] -- ^ aggregate function name
      ,ScalarExpr -> SetQuantifier
aggDistinct :: SetQuantifier -- ^ distinct
      ,ScalarExpr -> [ScalarExpr]
aggArgs :: [ScalarExpr]-- ^ args
      ,ScalarExpr -> [SortSpec]
aggOrderBy :: [SortSpec] -- ^ order by
      ,ScalarExpr -> Maybe ScalarExpr
aggFilter :: Maybe ScalarExpr -- ^ filter
      }
      -- | aggregates with within group
    | AggregateAppGroup
      {aggName :: [Name] -- ^ aggregate function name
      ,aggArgs :: [ScalarExpr] -- ^ args
      ,ScalarExpr -> [SortSpec]
aggGroup :: [SortSpec] -- ^ within group
      }
      -- | window application, which adds over (partition by a order
      -- by b) to regular function application. Explicit frames are
      -- not currently supported
    | WindowApp
      {ScalarExpr -> [Name]
wnName :: [Name] -- ^ window function name
      ,ScalarExpr -> [ScalarExpr]
wnArgs :: [ScalarExpr] -- ^ args
      ,ScalarExpr -> [ScalarExpr]
wnPartition :: [ScalarExpr] -- ^ partition by
      ,ScalarExpr -> [SortSpec]
wnOrderBy :: [SortSpec] -- ^ order by
      ,ScalarExpr -> Maybe Frame
wnFrame :: Maybe Frame -- ^ frame clause
      }

      -- | Used for the operators which look like functions
      -- except the arguments are separated by keywords instead
      -- of commas. The maybe is for the first unnamed argument
      -- if it is present, and the list is for the keyword argument
      -- pairs.
    | SpecialOpK [Name] (Maybe ScalarExpr) [(Text,ScalarExpr)]

      -- | cast(a as typename)
    | Cast ScalarExpr TypeName

      -- | convert expression to given datatype @CONVERT(data_type(length), expression, style)@
    | Convert TypeName ScalarExpr (Maybe Integer)

      -- | case expression. both flavours supported
    | Case
      {ScalarExpr -> Maybe ScalarExpr
caseTest :: Maybe ScalarExpr -- ^ test value
      ,ScalarExpr -> [([ScalarExpr], ScalarExpr)]
caseWhens :: [([ScalarExpr],ScalarExpr)] -- ^ when branches
      ,ScalarExpr -> Maybe ScalarExpr
caseElse :: Maybe ScalarExpr -- ^ else value
      }

    | Parens ScalarExpr

      -- | in list literal and in subquery, if the bool is false it
      -- means not in was used ('a not in (1,2)')
    | In Bool ScalarExpr InPredValue

      -- | exists, all, any, some subqueries
    | SubQueryExpr SubQueryExprType QueryExpr

    | QuantifiedComparison
            ScalarExpr
            [Name] -- operator
            CompPredQuantifier
            QueryExpr

    | Match ScalarExpr Bool -- true if unique
          QueryExpr
    | Array ScalarExpr [ScalarExpr] -- ^ represents an array
                                  -- access expression, or an array ctor
                                  -- e.g. a[3]. The first
                                  -- scalarExpr is the array, the
                                  -- second is the subscripts/ctor args
    | ArrayCtor QueryExpr -- ^ this is used for the query expression version of array constructors, e.g. array(select * from t)

{-
todo: special syntax for like, similar with escape - escape cannot go
in other places
-}

    --  | Escape ScalarExpr Char
    --  | UEscape ScalarExpr Char
    | Collate ScalarExpr [Name]
    | MultisetBinOp ScalarExpr SetOperatorName SetQuantifier ScalarExpr
    | MultisetCtor [ScalarExpr]
    | MultisetQueryCtor QueryExpr
    | NextValueFor [Name]
    | VEComment [Comment] ScalarExpr
    | OdbcLiteral OdbcLiteralType Text
      -- ^ an odbc literal e.g. {d '2000-01-01'}
    | OdbcFunc ScalarExpr
      -- ^ an odbc function call e.g. {fn CHARACTER_LENGTH('test')}
      deriving (ScalarExpr -> ScalarExpr -> Bool
(ScalarExpr -> ScalarExpr -> Bool)
-> (ScalarExpr -> ScalarExpr -> Bool) -> Eq ScalarExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ScalarExpr -> ScalarExpr -> Bool
== :: ScalarExpr -> ScalarExpr -> Bool
$c/= :: ScalarExpr -> ScalarExpr -> Bool
/= :: ScalarExpr -> ScalarExpr -> Bool
Eq,Int -> ScalarExpr -> ShowS
[ScalarExpr] -> ShowS
ScalarExpr -> String
(Int -> ScalarExpr -> ShowS)
-> (ScalarExpr -> String)
-> ([ScalarExpr] -> ShowS)
-> Show ScalarExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ScalarExpr -> ShowS
showsPrec :: Int -> ScalarExpr -> ShowS
$cshow :: ScalarExpr -> String
show :: ScalarExpr -> String
$cshowList :: [ScalarExpr] -> ShowS
showList :: [ScalarExpr] -> ShowS
Show,ReadPrec [ScalarExpr]
ReadPrec ScalarExpr
Int -> ReadS ScalarExpr
ReadS [ScalarExpr]
(Int -> ReadS ScalarExpr)
-> ReadS [ScalarExpr]
-> ReadPrec ScalarExpr
-> ReadPrec [ScalarExpr]
-> Read ScalarExpr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ScalarExpr
readsPrec :: Int -> ReadS ScalarExpr
$creadList :: ReadS [ScalarExpr]
readList :: ReadS [ScalarExpr]
$creadPrec :: ReadPrec ScalarExpr
readPrec :: ReadPrec ScalarExpr
$creadListPrec :: ReadPrec [ScalarExpr]
readListPrec :: ReadPrec [ScalarExpr]
Read,Typeable ScalarExpr
Typeable ScalarExpr =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ScalarExpr -> c ScalarExpr)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ScalarExpr)
-> (ScalarExpr -> Constr)
-> (ScalarExpr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ScalarExpr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ScalarExpr))
-> ((forall b. Data b => b -> b) -> ScalarExpr -> ScalarExpr)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ScalarExpr -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ScalarExpr -> r)
-> (forall u. (forall d. Data d => d -> u) -> ScalarExpr -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ScalarExpr -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr)
-> Data ScalarExpr
ScalarExpr -> Constr
ScalarExpr -> DataType
(forall b. Data b => b -> b) -> ScalarExpr -> ScalarExpr
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) -> ScalarExpr -> u
forall u. (forall d. Data d => d -> u) -> ScalarExpr -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ScalarExpr -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ScalarExpr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ScalarExpr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ScalarExpr -> c ScalarExpr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ScalarExpr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ScalarExpr)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ScalarExpr -> c ScalarExpr
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ScalarExpr -> c ScalarExpr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ScalarExpr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ScalarExpr
$ctoConstr :: ScalarExpr -> Constr
toConstr :: ScalarExpr -> Constr
$cdataTypeOf :: ScalarExpr -> DataType
dataTypeOf :: ScalarExpr -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ScalarExpr)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ScalarExpr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ScalarExpr)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ScalarExpr)
$cgmapT :: (forall b. Data b => b -> b) -> ScalarExpr -> ScalarExpr
gmapT :: (forall b. Data b => b -> b) -> ScalarExpr -> ScalarExpr
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ScalarExpr -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ScalarExpr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ScalarExpr -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ScalarExpr -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ScalarExpr -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ScalarExpr -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ScalarExpr -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ScalarExpr -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr
Data,Typeable)

-- | Represents an identifier name, which can be quoted or unquoted.
-- examples:
--
-- * test -> Name Nothing "test"
-- * "test" -> Name (Just "\"","\"") "test"
-- * `something` -> Name (Just ("`","`") "something"
-- * [ms] -> Name (Just ("[","]") "ms"
data Name = Name (Maybe (Text,Text)) Text
            deriving (Name -> Name -> Bool
(Name -> Name -> Bool) -> (Name -> Name -> Bool) -> Eq Name
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
/= :: Name -> Name -> Bool
Eq,Int -> Name -> ShowS
[Name] -> ShowS
Name -> String
(Int -> Name -> ShowS)
-> (Name -> String) -> ([Name] -> ShowS) -> Show Name
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Name -> ShowS
showsPrec :: Int -> Name -> ShowS
$cshow :: Name -> String
show :: Name -> String
$cshowList :: [Name] -> ShowS
showList :: [Name] -> ShowS
Show,ReadPrec [Name]
ReadPrec Name
Int -> ReadS Name
ReadS [Name]
(Int -> ReadS Name)
-> ReadS [Name] -> ReadPrec Name -> ReadPrec [Name] -> Read Name
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Name
readsPrec :: Int -> ReadS Name
$creadList :: ReadS [Name]
readList :: ReadS [Name]
$creadPrec :: ReadPrec Name
readPrec :: ReadPrec Name
$creadListPrec :: ReadPrec [Name]
readListPrec :: ReadPrec [Name]
Read,Typeable Name
Typeable Name =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Name -> c Name)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Name)
-> (Name -> Constr)
-> (Name -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Name))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name))
-> ((forall b. Data b => b -> b) -> Name -> Name)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r)
-> (forall u. (forall d. Data d => d -> u) -> Name -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Name -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> Data Name
Name -> Constr
Name -> DataType
(forall b. Data b => b -> b) -> Name -> Name
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) -> Name -> u
forall u. (forall d. Data d => d -> u) -> Name -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
$ctoConstr :: Name -> Constr
toConstr :: Name -> Constr
$cdataTypeOf :: Name -> DataType
dataTypeOf :: Name -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cgmapT :: (forall b. Data b => b -> b) -> Name -> Name
gmapT :: (forall b. Data b => b -> b) -> Name -> Name
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Name -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Name -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
Data,Typeable)

-- | Represents a type name, used in casts.
data TypeName
    = TypeName [Name]
    | PrecTypeName [Name] Integer
    | PrecScaleTypeName [Name] Integer Integer
    | PrecLengthTypeName [Name] Integer (Maybe PrecMultiplier) (Maybe PrecUnits)
      -- precision, characterset, collate
    | CharTypeName [Name] (Maybe Integer) [Name] [Name]
    | TimeTypeName [Name] (Maybe Integer) Bool -- true == with time zone
    | RowTypeName [(Name,TypeName)]
    | IntervalTypeName IntervalTypeField (Maybe IntervalTypeField)
    | ArrayTypeName TypeName (Maybe Integer)
    | MultisetTypeName TypeName
      deriving (TypeName -> TypeName -> Bool
(TypeName -> TypeName -> Bool)
-> (TypeName -> TypeName -> Bool) -> Eq TypeName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeName -> TypeName -> Bool
== :: TypeName -> TypeName -> Bool
$c/= :: TypeName -> TypeName -> Bool
/= :: TypeName -> TypeName -> Bool
Eq,Int -> TypeName -> ShowS
[TypeName] -> ShowS
TypeName -> String
(Int -> TypeName -> ShowS)
-> (TypeName -> String) -> ([TypeName] -> ShowS) -> Show TypeName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TypeName -> ShowS
showsPrec :: Int -> TypeName -> ShowS
$cshow :: TypeName -> String
show :: TypeName -> String
$cshowList :: [TypeName] -> ShowS
showList :: [TypeName] -> ShowS
Show,ReadPrec [TypeName]
ReadPrec TypeName
Int -> ReadS TypeName
ReadS [TypeName]
(Int -> ReadS TypeName)
-> ReadS [TypeName]
-> ReadPrec TypeName
-> ReadPrec [TypeName]
-> Read TypeName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TypeName
readsPrec :: Int -> ReadS TypeName
$creadList :: ReadS [TypeName]
readList :: ReadS [TypeName]
$creadPrec :: ReadPrec TypeName
readPrec :: ReadPrec TypeName
$creadListPrec :: ReadPrec [TypeName]
readListPrec :: ReadPrec [TypeName]
Read,Typeable TypeName
Typeable TypeName =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TypeName -> c TypeName)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypeName)
-> (TypeName -> Constr)
-> (TypeName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypeName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeName))
-> ((forall b. Data b => b -> b) -> TypeName -> TypeName)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeName -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeName -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypeName -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TypeName -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypeName -> m TypeName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeName -> m TypeName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeName -> m TypeName)
-> Data TypeName
TypeName -> Constr
TypeName -> DataType
(forall b. Data b => b -> b) -> TypeName -> TypeName
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) -> TypeName -> u
forall u. (forall d. Data d => d -> u) -> TypeName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeName -> m TypeName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeName -> m TypeName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeName -> c TypeName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeName)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeName -> c TypeName
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeName -> c TypeName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeName
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeName
$ctoConstr :: TypeName -> Constr
toConstr :: TypeName -> Constr
$cdataTypeOf :: TypeName -> DataType
dataTypeOf :: TypeName -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeName)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeName)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeName)
$cgmapT :: (forall b. Data b => b -> b) -> TypeName -> TypeName
gmapT :: (forall b. Data b => b -> b) -> TypeName -> TypeName
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeName -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeName -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeName -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeName -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TypeName -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeName -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeName -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeName -> m TypeName
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeName -> m TypeName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeName -> m TypeName
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeName -> m TypeName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeName -> m TypeName
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeName -> m TypeName
Data,Typeable)

data IntervalTypeField = Itf Text (Maybe (Integer, Maybe Integer))
                         deriving (IntervalTypeField -> IntervalTypeField -> Bool
(IntervalTypeField -> IntervalTypeField -> Bool)
-> (IntervalTypeField -> IntervalTypeField -> Bool)
-> Eq IntervalTypeField
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IntervalTypeField -> IntervalTypeField -> Bool
== :: IntervalTypeField -> IntervalTypeField -> Bool
$c/= :: IntervalTypeField -> IntervalTypeField -> Bool
/= :: IntervalTypeField -> IntervalTypeField -> Bool
Eq,Int -> IntervalTypeField -> ShowS
[IntervalTypeField] -> ShowS
IntervalTypeField -> String
(Int -> IntervalTypeField -> ShowS)
-> (IntervalTypeField -> String)
-> ([IntervalTypeField] -> ShowS)
-> Show IntervalTypeField
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IntervalTypeField -> ShowS
showsPrec :: Int -> IntervalTypeField -> ShowS
$cshow :: IntervalTypeField -> String
show :: IntervalTypeField -> String
$cshowList :: [IntervalTypeField] -> ShowS
showList :: [IntervalTypeField] -> ShowS
Show,ReadPrec [IntervalTypeField]
ReadPrec IntervalTypeField
Int -> ReadS IntervalTypeField
ReadS [IntervalTypeField]
(Int -> ReadS IntervalTypeField)
-> ReadS [IntervalTypeField]
-> ReadPrec IntervalTypeField
-> ReadPrec [IntervalTypeField]
-> Read IntervalTypeField
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IntervalTypeField
readsPrec :: Int -> ReadS IntervalTypeField
$creadList :: ReadS [IntervalTypeField]
readList :: ReadS [IntervalTypeField]
$creadPrec :: ReadPrec IntervalTypeField
readPrec :: ReadPrec IntervalTypeField
$creadListPrec :: ReadPrec [IntervalTypeField]
readListPrec :: ReadPrec [IntervalTypeField]
Read,Typeable IntervalTypeField
Typeable IntervalTypeField =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> IntervalTypeField
 -> c IntervalTypeField)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c IntervalTypeField)
-> (IntervalTypeField -> Constr)
-> (IntervalTypeField -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c IntervalTypeField))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c IntervalTypeField))
-> ((forall b. Data b => b -> b)
    -> IntervalTypeField -> IntervalTypeField)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IntervalTypeField -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IntervalTypeField -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> IntervalTypeField -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> IntervalTypeField -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> IntervalTypeField -> m IntervalTypeField)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IntervalTypeField -> m IntervalTypeField)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IntervalTypeField -> m IntervalTypeField)
-> Data IntervalTypeField
IntervalTypeField -> Constr
IntervalTypeField -> DataType
(forall b. Data b => b -> b)
-> IntervalTypeField -> IntervalTypeField
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) -> IntervalTypeField -> u
forall u. (forall d. Data d => d -> u) -> IntervalTypeField -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IntervalTypeField -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IntervalTypeField -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> IntervalTypeField -> m IntervalTypeField
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IntervalTypeField -> m IntervalTypeField
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IntervalTypeField
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IntervalTypeField -> c IntervalTypeField
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IntervalTypeField)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IntervalTypeField)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IntervalTypeField -> c IntervalTypeField
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IntervalTypeField -> c IntervalTypeField
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IntervalTypeField
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IntervalTypeField
$ctoConstr :: IntervalTypeField -> Constr
toConstr :: IntervalTypeField -> Constr
$cdataTypeOf :: IntervalTypeField -> DataType
dataTypeOf :: IntervalTypeField -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IntervalTypeField)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IntervalTypeField)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IntervalTypeField)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IntervalTypeField)
$cgmapT :: (forall b. Data b => b -> b)
-> IntervalTypeField -> IntervalTypeField
gmapT :: (forall b. Data b => b -> b)
-> IntervalTypeField -> IntervalTypeField
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IntervalTypeField -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IntervalTypeField -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IntervalTypeField -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IntervalTypeField -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IntervalTypeField -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> IntervalTypeField -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> IntervalTypeField -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> IntervalTypeField -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> IntervalTypeField -> m IntervalTypeField
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> IntervalTypeField -> m IntervalTypeField
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IntervalTypeField -> m IntervalTypeField
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IntervalTypeField -> m IntervalTypeField
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IntervalTypeField -> m IntervalTypeField
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IntervalTypeField -> m IntervalTypeField
Data,Typeable)

data Sign = Plus | Minus
            deriving (Sign -> Sign -> Bool
(Sign -> Sign -> Bool) -> (Sign -> Sign -> Bool) -> Eq Sign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Sign -> Sign -> Bool
== :: Sign -> Sign -> Bool
$c/= :: Sign -> Sign -> Bool
/= :: Sign -> Sign -> Bool
Eq,Int -> Sign -> ShowS
[Sign] -> ShowS
Sign -> String
(Int -> Sign -> ShowS)
-> (Sign -> String) -> ([Sign] -> ShowS) -> Show Sign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Sign -> ShowS
showsPrec :: Int -> Sign -> ShowS
$cshow :: Sign -> String
show :: Sign -> String
$cshowList :: [Sign] -> ShowS
showList :: [Sign] -> ShowS
Show,ReadPrec [Sign]
ReadPrec Sign
Int -> ReadS Sign
ReadS [Sign]
(Int -> ReadS Sign)
-> ReadS [Sign] -> ReadPrec Sign -> ReadPrec [Sign] -> Read Sign
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Sign
readsPrec :: Int -> ReadS Sign
$creadList :: ReadS [Sign]
readList :: ReadS [Sign]
$creadPrec :: ReadPrec Sign
readPrec :: ReadPrec Sign
$creadListPrec :: ReadPrec [Sign]
readListPrec :: ReadPrec [Sign]
Read,Typeable Sign
Typeable Sign =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Sign -> c Sign)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Sign)
-> (Sign -> Constr)
-> (Sign -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Sign))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign))
-> ((forall b. Data b => b -> b) -> Sign -> Sign)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r)
-> (forall u. (forall d. Data d => d -> u) -> Sign -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Sign -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Sign -> m Sign)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sign -> m Sign)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sign -> m Sign)
-> Data Sign
Sign -> Constr
Sign -> DataType
(forall b. Data b => b -> b) -> Sign -> Sign
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) -> Sign -> u
forall u. (forall d. Data d => d -> u) -> Sign -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sign)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
$ctoConstr :: Sign -> Constr
toConstr :: Sign -> Constr
$cdataTypeOf :: Sign -> DataType
dataTypeOf :: Sign -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sign)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sign)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign)
$cgmapT :: (forall b. Data b => b -> b) -> Sign -> Sign
gmapT :: (forall b. Data b => b -> b) -> Sign -> Sign
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Sign -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Sign -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Sign -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Sign -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
Data,Typeable)

data PrecMultiplier = PrecK | PrecM | PrecG | PrecT | PrecP
                      deriving (PrecMultiplier -> PrecMultiplier -> Bool
(PrecMultiplier -> PrecMultiplier -> Bool)
-> (PrecMultiplier -> PrecMultiplier -> Bool) -> Eq PrecMultiplier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PrecMultiplier -> PrecMultiplier -> Bool
== :: PrecMultiplier -> PrecMultiplier -> Bool
$c/= :: PrecMultiplier -> PrecMultiplier -> Bool
/= :: PrecMultiplier -> PrecMultiplier -> Bool
Eq,Int -> PrecMultiplier -> ShowS
[PrecMultiplier] -> ShowS
PrecMultiplier -> String
(Int -> PrecMultiplier -> ShowS)
-> (PrecMultiplier -> String)
-> ([PrecMultiplier] -> ShowS)
-> Show PrecMultiplier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PrecMultiplier -> ShowS
showsPrec :: Int -> PrecMultiplier -> ShowS
$cshow :: PrecMultiplier -> String
show :: PrecMultiplier -> String
$cshowList :: [PrecMultiplier] -> ShowS
showList :: [PrecMultiplier] -> ShowS
Show,ReadPrec [PrecMultiplier]
ReadPrec PrecMultiplier
Int -> ReadS PrecMultiplier
ReadS [PrecMultiplier]
(Int -> ReadS PrecMultiplier)
-> ReadS [PrecMultiplier]
-> ReadPrec PrecMultiplier
-> ReadPrec [PrecMultiplier]
-> Read PrecMultiplier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PrecMultiplier
readsPrec :: Int -> ReadS PrecMultiplier
$creadList :: ReadS [PrecMultiplier]
readList :: ReadS [PrecMultiplier]
$creadPrec :: ReadPrec PrecMultiplier
readPrec :: ReadPrec PrecMultiplier
$creadListPrec :: ReadPrec [PrecMultiplier]
readListPrec :: ReadPrec [PrecMultiplier]
Read,Typeable PrecMultiplier
Typeable PrecMultiplier =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PrecMultiplier -> c PrecMultiplier)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PrecMultiplier)
-> (PrecMultiplier -> Constr)
-> (PrecMultiplier -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PrecMultiplier))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c PrecMultiplier))
-> ((forall b. Data b => b -> b)
    -> PrecMultiplier -> PrecMultiplier)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PrecMultiplier -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PrecMultiplier -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> PrecMultiplier -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PrecMultiplier -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PrecMultiplier -> m PrecMultiplier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PrecMultiplier -> m PrecMultiplier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PrecMultiplier -> m PrecMultiplier)
-> Data PrecMultiplier
PrecMultiplier -> Constr
PrecMultiplier -> DataType
(forall b. Data b => b -> b) -> PrecMultiplier -> PrecMultiplier
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) -> PrecMultiplier -> u
forall u. (forall d. Data d => d -> u) -> PrecMultiplier -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrecMultiplier -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrecMultiplier -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PrecMultiplier -> m PrecMultiplier
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrecMultiplier -> m PrecMultiplier
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrecMultiplier
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrecMultiplier -> c PrecMultiplier
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrecMultiplier)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrecMultiplier)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrecMultiplier -> c PrecMultiplier
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrecMultiplier -> c PrecMultiplier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrecMultiplier
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrecMultiplier
$ctoConstr :: PrecMultiplier -> Constr
toConstr :: PrecMultiplier -> Constr
$cdataTypeOf :: PrecMultiplier -> DataType
dataTypeOf :: PrecMultiplier -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrecMultiplier)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrecMultiplier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrecMultiplier)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrecMultiplier)
$cgmapT :: (forall b. Data b => b -> b) -> PrecMultiplier -> PrecMultiplier
gmapT :: (forall b. Data b => b -> b) -> PrecMultiplier -> PrecMultiplier
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrecMultiplier -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrecMultiplier -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrecMultiplier -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrecMultiplier -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PrecMultiplier -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PrecMultiplier -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PrecMultiplier -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PrecMultiplier -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PrecMultiplier -> m PrecMultiplier
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PrecMultiplier -> m PrecMultiplier
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrecMultiplier -> m PrecMultiplier
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrecMultiplier -> m PrecMultiplier
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrecMultiplier -> m PrecMultiplier
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrecMultiplier -> m PrecMultiplier
Data,Typeable)
data PrecUnits = PrecCharacters
               | PrecOctets
                deriving (PrecUnits -> PrecUnits -> Bool
(PrecUnits -> PrecUnits -> Bool)
-> (PrecUnits -> PrecUnits -> Bool) -> Eq PrecUnits
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PrecUnits -> PrecUnits -> Bool
== :: PrecUnits -> PrecUnits -> Bool
$c/= :: PrecUnits -> PrecUnits -> Bool
/= :: PrecUnits -> PrecUnits -> Bool
Eq,Int -> PrecUnits -> ShowS
[PrecUnits] -> ShowS
PrecUnits -> String
(Int -> PrecUnits -> ShowS)
-> (PrecUnits -> String)
-> ([PrecUnits] -> ShowS)
-> Show PrecUnits
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PrecUnits -> ShowS
showsPrec :: Int -> PrecUnits -> ShowS
$cshow :: PrecUnits -> String
show :: PrecUnits -> String
$cshowList :: [PrecUnits] -> ShowS
showList :: [PrecUnits] -> ShowS
Show,ReadPrec [PrecUnits]
ReadPrec PrecUnits
Int -> ReadS PrecUnits
ReadS [PrecUnits]
(Int -> ReadS PrecUnits)
-> ReadS [PrecUnits]
-> ReadPrec PrecUnits
-> ReadPrec [PrecUnits]
-> Read PrecUnits
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PrecUnits
readsPrec :: Int -> ReadS PrecUnits
$creadList :: ReadS [PrecUnits]
readList :: ReadS [PrecUnits]
$creadPrec :: ReadPrec PrecUnits
readPrec :: ReadPrec PrecUnits
$creadListPrec :: ReadPrec [PrecUnits]
readListPrec :: ReadPrec [PrecUnits]
Read,Typeable PrecUnits
Typeable PrecUnits =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PrecUnits -> c PrecUnits)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PrecUnits)
-> (PrecUnits -> Constr)
-> (PrecUnits -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PrecUnits))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrecUnits))
-> ((forall b. Data b => b -> b) -> PrecUnits -> PrecUnits)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PrecUnits -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PrecUnits -> r)
-> (forall u. (forall d. Data d => d -> u) -> PrecUnits -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PrecUnits -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits)
-> Data PrecUnits
PrecUnits -> Constr
PrecUnits -> DataType
(forall b. Data b => b -> b) -> PrecUnits -> PrecUnits
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) -> PrecUnits -> u
forall u. (forall d. Data d => d -> u) -> PrecUnits -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrecUnits -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrecUnits -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrecUnits
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrecUnits -> c PrecUnits
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrecUnits)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrecUnits)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrecUnits -> c PrecUnits
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrecUnits -> c PrecUnits
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrecUnits
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrecUnits
$ctoConstr :: PrecUnits -> Constr
toConstr :: PrecUnits -> Constr
$cdataTypeOf :: PrecUnits -> DataType
dataTypeOf :: PrecUnits -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrecUnits)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrecUnits)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrecUnits)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrecUnits)
$cgmapT :: (forall b. Data b => b -> b) -> PrecUnits -> PrecUnits
gmapT :: (forall b. Data b => b -> b) -> PrecUnits -> PrecUnits
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrecUnits -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrecUnits -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrecUnits -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrecUnits -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PrecUnits -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PrecUnits -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PrecUnits -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PrecUnits -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits
Data,Typeable)

-- | Used for 'expr in (scalar expression list)', and 'expr in
-- (subquery)' syntax.
data InPredValue = InList [ScalarExpr]
                 | InQueryExpr QueryExpr
                   deriving (InPredValue -> InPredValue -> Bool
(InPredValue -> InPredValue -> Bool)
-> (InPredValue -> InPredValue -> Bool) -> Eq InPredValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InPredValue -> InPredValue -> Bool
== :: InPredValue -> InPredValue -> Bool
$c/= :: InPredValue -> InPredValue -> Bool
/= :: InPredValue -> InPredValue -> Bool
Eq,Int -> InPredValue -> ShowS
[InPredValue] -> ShowS
InPredValue -> String
(Int -> InPredValue -> ShowS)
-> (InPredValue -> String)
-> ([InPredValue] -> ShowS)
-> Show InPredValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InPredValue -> ShowS
showsPrec :: Int -> InPredValue -> ShowS
$cshow :: InPredValue -> String
show :: InPredValue -> String
$cshowList :: [InPredValue] -> ShowS
showList :: [InPredValue] -> ShowS
Show,ReadPrec [InPredValue]
ReadPrec InPredValue
Int -> ReadS InPredValue
ReadS [InPredValue]
(Int -> ReadS InPredValue)
-> ReadS [InPredValue]
-> ReadPrec InPredValue
-> ReadPrec [InPredValue]
-> Read InPredValue
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InPredValue
readsPrec :: Int -> ReadS InPredValue
$creadList :: ReadS [InPredValue]
readList :: ReadS [InPredValue]
$creadPrec :: ReadPrec InPredValue
readPrec :: ReadPrec InPredValue
$creadListPrec :: ReadPrec [InPredValue]
readListPrec :: ReadPrec [InPredValue]
Read,Typeable InPredValue
Typeable InPredValue =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> InPredValue -> c InPredValue)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c InPredValue)
-> (InPredValue -> Constr)
-> (InPredValue -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c InPredValue))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c InPredValue))
-> ((forall b. Data b => b -> b) -> InPredValue -> InPredValue)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InPredValue -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InPredValue -> r)
-> (forall u. (forall d. Data d => d -> u) -> InPredValue -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> InPredValue -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> InPredValue -> m InPredValue)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InPredValue -> m InPredValue)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InPredValue -> m InPredValue)
-> Data InPredValue
InPredValue -> Constr
InPredValue -> DataType
(forall b. Data b => b -> b) -> InPredValue -> InPredValue
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) -> InPredValue -> u
forall u. (forall d. Data d => d -> u) -> InPredValue -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InPredValue -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InPredValue -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InPredValue -> m InPredValue
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InPredValue -> m InPredValue
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InPredValue
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InPredValue -> c InPredValue
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InPredValue)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InPredValue)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InPredValue -> c InPredValue
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InPredValue -> c InPredValue
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InPredValue
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InPredValue
$ctoConstr :: InPredValue -> Constr
toConstr :: InPredValue -> Constr
$cdataTypeOf :: InPredValue -> DataType
dataTypeOf :: InPredValue -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InPredValue)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InPredValue)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InPredValue)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InPredValue)
$cgmapT :: (forall b. Data b => b -> b) -> InPredValue -> InPredValue
gmapT :: (forall b. Data b => b -> b) -> InPredValue -> InPredValue
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InPredValue -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InPredValue -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InPredValue -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InPredValue -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> InPredValue -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> InPredValue -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InPredValue -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InPredValue -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InPredValue -> m InPredValue
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InPredValue -> m InPredValue
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InPredValue -> m InPredValue
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InPredValue -> m InPredValue
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InPredValue -> m InPredValue
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InPredValue -> m InPredValue
Data,Typeable)

-- not sure if scalar subquery, exists and unique should be represented like this

-- | A subquery in a scalar expression.
data SubQueryExprType
    = -- | exists (query expr)
      SqExists
      -- | unique (query expr)
    | SqUnique
      -- | a scalar subquery
    | SqSq
      deriving (SubQueryExprType -> SubQueryExprType -> Bool
(SubQueryExprType -> SubQueryExprType -> Bool)
-> (SubQueryExprType -> SubQueryExprType -> Bool)
-> Eq SubQueryExprType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SubQueryExprType -> SubQueryExprType -> Bool
== :: SubQueryExprType -> SubQueryExprType -> Bool
$c/= :: SubQueryExprType -> SubQueryExprType -> Bool
/= :: SubQueryExprType -> SubQueryExprType -> Bool
Eq,Int -> SubQueryExprType -> ShowS
[SubQueryExprType] -> ShowS
SubQueryExprType -> String
(Int -> SubQueryExprType -> ShowS)
-> (SubQueryExprType -> String)
-> ([SubQueryExprType] -> ShowS)
-> Show SubQueryExprType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SubQueryExprType -> ShowS
showsPrec :: Int -> SubQueryExprType -> ShowS
$cshow :: SubQueryExprType -> String
show :: SubQueryExprType -> String
$cshowList :: [SubQueryExprType] -> ShowS
showList :: [SubQueryExprType] -> ShowS
Show,ReadPrec [SubQueryExprType]
ReadPrec SubQueryExprType
Int -> ReadS SubQueryExprType
ReadS [SubQueryExprType]
(Int -> ReadS SubQueryExprType)
-> ReadS [SubQueryExprType]
-> ReadPrec SubQueryExprType
-> ReadPrec [SubQueryExprType]
-> Read SubQueryExprType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SubQueryExprType
readsPrec :: Int -> ReadS SubQueryExprType
$creadList :: ReadS [SubQueryExprType]
readList :: ReadS [SubQueryExprType]
$creadPrec :: ReadPrec SubQueryExprType
readPrec :: ReadPrec SubQueryExprType
$creadListPrec :: ReadPrec [SubQueryExprType]
readListPrec :: ReadPrec [SubQueryExprType]
Read,Typeable SubQueryExprType
Typeable SubQueryExprType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SubQueryExprType -> c SubQueryExprType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SubQueryExprType)
-> (SubQueryExprType -> Constr)
-> (SubQueryExprType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SubQueryExprType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SubQueryExprType))
-> ((forall b. Data b => b -> b)
    -> SubQueryExprType -> SubQueryExprType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SubQueryExprType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SubQueryExprType -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SubQueryExprType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SubQueryExprType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SubQueryExprType -> m SubQueryExprType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SubQueryExprType -> m SubQueryExprType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SubQueryExprType -> m SubQueryExprType)
-> Data SubQueryExprType
SubQueryExprType -> Constr
SubQueryExprType -> DataType
(forall b. Data b => b -> b)
-> SubQueryExprType -> SubQueryExprType
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) -> SubQueryExprType -> u
forall u. (forall d. Data d => d -> u) -> SubQueryExprType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubQueryExprType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SubQueryExprType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SubQueryExprType -> m SubQueryExprType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SubQueryExprType -> m SubQueryExprType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubQueryExprType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubQueryExprType -> c SubQueryExprType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SubQueryExprType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SubQueryExprType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubQueryExprType -> c SubQueryExprType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubQueryExprType -> c SubQueryExprType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubQueryExprType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubQueryExprType
$ctoConstr :: SubQueryExprType -> Constr
toConstr :: SubQueryExprType -> Constr
$cdataTypeOf :: SubQueryExprType -> DataType
dataTypeOf :: SubQueryExprType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SubQueryExprType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SubQueryExprType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SubQueryExprType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SubQueryExprType)
$cgmapT :: (forall b. Data b => b -> b)
-> SubQueryExprType -> SubQueryExprType
gmapT :: (forall b. Data b => b -> b)
-> SubQueryExprType -> SubQueryExprType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubQueryExprType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubQueryExprType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SubQueryExprType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SubQueryExprType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SubQueryExprType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SubQueryExprType -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SubQueryExprType -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SubQueryExprType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SubQueryExprType -> m SubQueryExprType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SubQueryExprType -> m SubQueryExprType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SubQueryExprType -> m SubQueryExprType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SubQueryExprType -> m SubQueryExprType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SubQueryExprType -> m SubQueryExprType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SubQueryExprType -> m SubQueryExprType
Data,Typeable)

data CompPredQuantifier
    = CPAny
    | CPSome
    | CPAll
      deriving (CompPredQuantifier -> CompPredQuantifier -> Bool
(CompPredQuantifier -> CompPredQuantifier -> Bool)
-> (CompPredQuantifier -> CompPredQuantifier -> Bool)
-> Eq CompPredQuantifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CompPredQuantifier -> CompPredQuantifier -> Bool
== :: CompPredQuantifier -> CompPredQuantifier -> Bool
$c/= :: CompPredQuantifier -> CompPredQuantifier -> Bool
/= :: CompPredQuantifier -> CompPredQuantifier -> Bool
Eq,Int -> CompPredQuantifier -> ShowS
[CompPredQuantifier] -> ShowS
CompPredQuantifier -> String
(Int -> CompPredQuantifier -> ShowS)
-> (CompPredQuantifier -> String)
-> ([CompPredQuantifier] -> ShowS)
-> Show CompPredQuantifier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CompPredQuantifier -> ShowS
showsPrec :: Int -> CompPredQuantifier -> ShowS
$cshow :: CompPredQuantifier -> String
show :: CompPredQuantifier -> String
$cshowList :: [CompPredQuantifier] -> ShowS
showList :: [CompPredQuantifier] -> ShowS
Show,ReadPrec [CompPredQuantifier]
ReadPrec CompPredQuantifier
Int -> ReadS CompPredQuantifier
ReadS [CompPredQuantifier]
(Int -> ReadS CompPredQuantifier)
-> ReadS [CompPredQuantifier]
-> ReadPrec CompPredQuantifier
-> ReadPrec [CompPredQuantifier]
-> Read CompPredQuantifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CompPredQuantifier
readsPrec :: Int -> ReadS CompPredQuantifier
$creadList :: ReadS [CompPredQuantifier]
readList :: ReadS [CompPredQuantifier]
$creadPrec :: ReadPrec CompPredQuantifier
readPrec :: ReadPrec CompPredQuantifier
$creadListPrec :: ReadPrec [CompPredQuantifier]
readListPrec :: ReadPrec [CompPredQuantifier]
Read,Typeable CompPredQuantifier
Typeable CompPredQuantifier =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> CompPredQuantifier
 -> c CompPredQuantifier)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CompPredQuantifier)
-> (CompPredQuantifier -> Constr)
-> (CompPredQuantifier -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CompPredQuantifier))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CompPredQuantifier))
-> ((forall b. Data b => b -> b)
    -> CompPredQuantifier -> CompPredQuantifier)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CompPredQuantifier -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CompPredQuantifier -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> CompPredQuantifier -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CompPredQuantifier -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CompPredQuantifier -> m CompPredQuantifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CompPredQuantifier -> m CompPredQuantifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CompPredQuantifier -> m CompPredQuantifier)
-> Data CompPredQuantifier
CompPredQuantifier -> Constr
CompPredQuantifier -> DataType
(forall b. Data b => b -> b)
-> CompPredQuantifier -> CompPredQuantifier
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) -> CompPredQuantifier -> u
forall u. (forall d. Data d => d -> u) -> CompPredQuantifier -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompPredQuantifier -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompPredQuantifier -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CompPredQuantifier -> m CompPredQuantifier
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompPredQuantifier -> m CompPredQuantifier
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompPredQuantifier
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CompPredQuantifier
-> c CompPredQuantifier
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CompPredQuantifier)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CompPredQuantifier)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CompPredQuantifier
-> c CompPredQuantifier
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CompPredQuantifier
-> c CompPredQuantifier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompPredQuantifier
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompPredQuantifier
$ctoConstr :: CompPredQuantifier -> Constr
toConstr :: CompPredQuantifier -> Constr
$cdataTypeOf :: CompPredQuantifier -> DataType
dataTypeOf :: CompPredQuantifier -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CompPredQuantifier)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CompPredQuantifier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CompPredQuantifier)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CompPredQuantifier)
$cgmapT :: (forall b. Data b => b -> b)
-> CompPredQuantifier -> CompPredQuantifier
gmapT :: (forall b. Data b => b -> b)
-> CompPredQuantifier -> CompPredQuantifier
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompPredQuantifier -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompPredQuantifier -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompPredQuantifier -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompPredQuantifier -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CompPredQuantifier -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CompPredQuantifier -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CompPredQuantifier -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CompPredQuantifier -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CompPredQuantifier -> m CompPredQuantifier
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CompPredQuantifier -> m CompPredQuantifier
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompPredQuantifier -> m CompPredQuantifier
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompPredQuantifier -> m CompPredQuantifier
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompPredQuantifier -> m CompPredQuantifier
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompPredQuantifier -> m CompPredQuantifier
Data,Typeable)

-- | Represents one field in an order by list.
data SortSpec = SortSpec ScalarExpr Direction NullsOrder
                deriving (SortSpec -> SortSpec -> Bool
(SortSpec -> SortSpec -> Bool)
-> (SortSpec -> SortSpec -> Bool) -> Eq SortSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SortSpec -> SortSpec -> Bool
== :: SortSpec -> SortSpec -> Bool
$c/= :: SortSpec -> SortSpec -> Bool
/= :: SortSpec -> SortSpec -> Bool
Eq,Int -> SortSpec -> ShowS
[SortSpec] -> ShowS
SortSpec -> String
(Int -> SortSpec -> ShowS)
-> (SortSpec -> String) -> ([SortSpec] -> ShowS) -> Show SortSpec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SortSpec -> ShowS
showsPrec :: Int -> SortSpec -> ShowS
$cshow :: SortSpec -> String
show :: SortSpec -> String
$cshowList :: [SortSpec] -> ShowS
showList :: [SortSpec] -> ShowS
Show,ReadPrec [SortSpec]
ReadPrec SortSpec
Int -> ReadS SortSpec
ReadS [SortSpec]
(Int -> ReadS SortSpec)
-> ReadS [SortSpec]
-> ReadPrec SortSpec
-> ReadPrec [SortSpec]
-> Read SortSpec
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SortSpec
readsPrec :: Int -> ReadS SortSpec
$creadList :: ReadS [SortSpec]
readList :: ReadS [SortSpec]
$creadPrec :: ReadPrec SortSpec
readPrec :: ReadPrec SortSpec
$creadListPrec :: ReadPrec [SortSpec]
readListPrec :: ReadPrec [SortSpec]
Read,Typeable SortSpec
Typeable SortSpec =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SortSpec -> c SortSpec)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SortSpec)
-> (SortSpec -> Constr)
-> (SortSpec -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SortSpec))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SortSpec))
-> ((forall b. Data b => b -> b) -> SortSpec -> SortSpec)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SortSpec -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SortSpec -> r)
-> (forall u. (forall d. Data d => d -> u) -> SortSpec -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SortSpec -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SortSpec -> m SortSpec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SortSpec -> m SortSpec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SortSpec -> m SortSpec)
-> Data SortSpec
SortSpec -> Constr
SortSpec -> DataType
(forall b. Data b => b -> b) -> SortSpec -> SortSpec
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) -> SortSpec -> u
forall u. (forall d. Data d => d -> u) -> SortSpec -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SortSpec -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SortSpec -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SortSpec -> m SortSpec
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SortSpec -> m SortSpec
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SortSpec
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SortSpec -> c SortSpec
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SortSpec)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SortSpec)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SortSpec -> c SortSpec
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SortSpec -> c SortSpec
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SortSpec
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SortSpec
$ctoConstr :: SortSpec -> Constr
toConstr :: SortSpec -> Constr
$cdataTypeOf :: SortSpec -> DataType
dataTypeOf :: SortSpec -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SortSpec)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SortSpec)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SortSpec)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SortSpec)
$cgmapT :: (forall b. Data b => b -> b) -> SortSpec -> SortSpec
gmapT :: (forall b. Data b => b -> b) -> SortSpec -> SortSpec
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SortSpec -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SortSpec -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SortSpec -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SortSpec -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SortSpec -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SortSpec -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SortSpec -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SortSpec -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SortSpec -> m SortSpec
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SortSpec -> m SortSpec
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SortSpec -> m SortSpec
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SortSpec -> m SortSpec
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SortSpec -> m SortSpec
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SortSpec -> m SortSpec
Data,Typeable)

-- | Represents 'nulls first' or 'nulls last' in an order by clause.
data NullsOrder = NullsOrderDefault
                | NullsFirst
                | NullsLast
                  deriving (NullsOrder -> NullsOrder -> Bool
(NullsOrder -> NullsOrder -> Bool)
-> (NullsOrder -> NullsOrder -> Bool) -> Eq NullsOrder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NullsOrder -> NullsOrder -> Bool
== :: NullsOrder -> NullsOrder -> Bool
$c/= :: NullsOrder -> NullsOrder -> Bool
/= :: NullsOrder -> NullsOrder -> Bool
Eq,Int -> NullsOrder -> ShowS
[NullsOrder] -> ShowS
NullsOrder -> String
(Int -> NullsOrder -> ShowS)
-> (NullsOrder -> String)
-> ([NullsOrder] -> ShowS)
-> Show NullsOrder
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NullsOrder -> ShowS
showsPrec :: Int -> NullsOrder -> ShowS
$cshow :: NullsOrder -> String
show :: NullsOrder -> String
$cshowList :: [NullsOrder] -> ShowS
showList :: [NullsOrder] -> ShowS
Show,ReadPrec [NullsOrder]
ReadPrec NullsOrder
Int -> ReadS NullsOrder
ReadS [NullsOrder]
(Int -> ReadS NullsOrder)
-> ReadS [NullsOrder]
-> ReadPrec NullsOrder
-> ReadPrec [NullsOrder]
-> Read NullsOrder
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NullsOrder
readsPrec :: Int -> ReadS NullsOrder
$creadList :: ReadS [NullsOrder]
readList :: ReadS [NullsOrder]
$creadPrec :: ReadPrec NullsOrder
readPrec :: ReadPrec NullsOrder
$creadListPrec :: ReadPrec [NullsOrder]
readListPrec :: ReadPrec [NullsOrder]
Read,Typeable NullsOrder
Typeable NullsOrder =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NullsOrder -> c NullsOrder)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NullsOrder)
-> (NullsOrder -> Constr)
-> (NullsOrder -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NullsOrder))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NullsOrder))
-> ((forall b. Data b => b -> b) -> NullsOrder -> NullsOrder)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NullsOrder -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NullsOrder -> r)
-> (forall u. (forall d. Data d => d -> u) -> NullsOrder -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NullsOrder -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder)
-> Data NullsOrder
NullsOrder -> Constr
NullsOrder -> DataType
(forall b. Data b => b -> b) -> NullsOrder -> NullsOrder
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) -> NullsOrder -> u
forall u. (forall d. Data d => d -> u) -> NullsOrder -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NullsOrder -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NullsOrder -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NullsOrder
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NullsOrder -> c NullsOrder
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NullsOrder)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NullsOrder)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NullsOrder -> c NullsOrder
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NullsOrder -> c NullsOrder
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NullsOrder
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NullsOrder
$ctoConstr :: NullsOrder -> Constr
toConstr :: NullsOrder -> Constr
$cdataTypeOf :: NullsOrder -> DataType
dataTypeOf :: NullsOrder -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NullsOrder)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NullsOrder)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NullsOrder)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NullsOrder)
$cgmapT :: (forall b. Data b => b -> b) -> NullsOrder -> NullsOrder
gmapT :: (forall b. Data b => b -> b) -> NullsOrder -> NullsOrder
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NullsOrder -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NullsOrder -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NullsOrder -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NullsOrder -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NullsOrder -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NullsOrder -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NullsOrder -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NullsOrder -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder
Data,Typeable)

-- | Represents the frame clause of a window
-- this can be [range | rows] frame_start
-- or [range | rows] between frame_start and frame_end
data Frame = FrameFrom FrameRows FramePos
           | FrameBetween FrameRows FramePos FramePos
             deriving (Frame -> Frame -> Bool
(Frame -> Frame -> Bool) -> (Frame -> Frame -> Bool) -> Eq Frame
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Frame -> Frame -> Bool
== :: Frame -> Frame -> Bool
$c/= :: Frame -> Frame -> Bool
/= :: Frame -> Frame -> Bool
Eq,Int -> Frame -> ShowS
[Frame] -> ShowS
Frame -> String
(Int -> Frame -> ShowS)
-> (Frame -> String) -> ([Frame] -> ShowS) -> Show Frame
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Frame -> ShowS
showsPrec :: Int -> Frame -> ShowS
$cshow :: Frame -> String
show :: Frame -> String
$cshowList :: [Frame] -> ShowS
showList :: [Frame] -> ShowS
Show,ReadPrec [Frame]
ReadPrec Frame
Int -> ReadS Frame
ReadS [Frame]
(Int -> ReadS Frame)
-> ReadS [Frame]
-> ReadPrec Frame
-> ReadPrec [Frame]
-> Read Frame
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Frame
readsPrec :: Int -> ReadS Frame
$creadList :: ReadS [Frame]
readList :: ReadS [Frame]
$creadPrec :: ReadPrec Frame
readPrec :: ReadPrec Frame
$creadListPrec :: ReadPrec [Frame]
readListPrec :: ReadPrec [Frame]
Read,Typeable Frame
Typeable Frame =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Frame -> c Frame)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Frame)
-> (Frame -> Constr)
-> (Frame -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Frame))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Frame))
-> ((forall b. Data b => b -> b) -> Frame -> Frame)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Frame -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Frame -> r)
-> (forall u. (forall d. Data d => d -> u) -> Frame -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Frame -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Frame -> m Frame)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Frame -> m Frame)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Frame -> m Frame)
-> Data Frame
Frame -> Constr
Frame -> DataType
(forall b. Data b => b -> b) -> Frame -> Frame
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) -> Frame -> u
forall u. (forall d. Data d => d -> u) -> Frame -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Frame -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Frame -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Frame -> m Frame
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Frame -> m Frame
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Frame
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Frame -> c Frame
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Frame)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Frame)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Frame -> c Frame
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Frame -> c Frame
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Frame
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Frame
$ctoConstr :: Frame -> Constr
toConstr :: Frame -> Constr
$cdataTypeOf :: Frame -> DataType
dataTypeOf :: Frame -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Frame)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Frame)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Frame)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Frame)
$cgmapT :: (forall b. Data b => b -> b) -> Frame -> Frame
gmapT :: (forall b. Data b => b -> b) -> Frame -> Frame
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Frame -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Frame -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Frame -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Frame -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Frame -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Frame -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Frame -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Frame -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Frame -> m Frame
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Frame -> m Frame
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Frame -> m Frame
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Frame -> m Frame
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Frame -> m Frame
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Frame -> m Frame
Data,Typeable)

-- | Represents whether a window frame clause is over rows or ranges.
data FrameRows = FrameRows | FrameRange
                 deriving (FrameRows -> FrameRows -> Bool
(FrameRows -> FrameRows -> Bool)
-> (FrameRows -> FrameRows -> Bool) -> Eq FrameRows
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FrameRows -> FrameRows -> Bool
== :: FrameRows -> FrameRows -> Bool
$c/= :: FrameRows -> FrameRows -> Bool
/= :: FrameRows -> FrameRows -> Bool
Eq,Int -> FrameRows -> ShowS
[FrameRows] -> ShowS
FrameRows -> String
(Int -> FrameRows -> ShowS)
-> (FrameRows -> String)
-> ([FrameRows] -> ShowS)
-> Show FrameRows
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FrameRows -> ShowS
showsPrec :: Int -> FrameRows -> ShowS
$cshow :: FrameRows -> String
show :: FrameRows -> String
$cshowList :: [FrameRows] -> ShowS
showList :: [FrameRows] -> ShowS
Show,ReadPrec [FrameRows]
ReadPrec FrameRows
Int -> ReadS FrameRows
ReadS [FrameRows]
(Int -> ReadS FrameRows)
-> ReadS [FrameRows]
-> ReadPrec FrameRows
-> ReadPrec [FrameRows]
-> Read FrameRows
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FrameRows
readsPrec :: Int -> ReadS FrameRows
$creadList :: ReadS [FrameRows]
readList :: ReadS [FrameRows]
$creadPrec :: ReadPrec FrameRows
readPrec :: ReadPrec FrameRows
$creadListPrec :: ReadPrec [FrameRows]
readListPrec :: ReadPrec [FrameRows]
Read,Typeable FrameRows
Typeable FrameRows =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FrameRows -> c FrameRows)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FrameRows)
-> (FrameRows -> Constr)
-> (FrameRows -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FrameRows))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FrameRows))
-> ((forall b. Data b => b -> b) -> FrameRows -> FrameRows)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FrameRows -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FrameRows -> r)
-> (forall u. (forall d. Data d => d -> u) -> FrameRows -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FrameRows -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FrameRows -> m FrameRows)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FrameRows -> m FrameRows)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FrameRows -> m FrameRows)
-> Data FrameRows
FrameRows -> Constr
FrameRows -> DataType
(forall b. Data b => b -> b) -> FrameRows -> FrameRows
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) -> FrameRows -> u
forall u. (forall d. Data d => d -> u) -> FrameRows -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FrameRows -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FrameRows -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FrameRows -> m FrameRows
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FrameRows -> m FrameRows
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FrameRows
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FrameRows -> c FrameRows
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FrameRows)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FrameRows)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FrameRows -> c FrameRows
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FrameRows -> c FrameRows
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FrameRows
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FrameRows
$ctoConstr :: FrameRows -> Constr
toConstr :: FrameRows -> Constr
$cdataTypeOf :: FrameRows -> DataType
dataTypeOf :: FrameRows -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FrameRows)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FrameRows)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FrameRows)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FrameRows)
$cgmapT :: (forall b. Data b => b -> b) -> FrameRows -> FrameRows
gmapT :: (forall b. Data b => b -> b) -> FrameRows -> FrameRows
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FrameRows -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FrameRows -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FrameRows -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FrameRows -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FrameRows -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FrameRows -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FrameRows -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FrameRows -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FrameRows -> m FrameRows
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FrameRows -> m FrameRows
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FrameRows -> m FrameRows
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FrameRows -> m FrameRows
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FrameRows -> m FrameRows
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FrameRows -> m FrameRows
Data,Typeable)

-- | represents the start or end of a frame
data FramePos = UnboundedPreceding
              | Preceding ScalarExpr
              | Current
              | Following ScalarExpr
              | UnboundedFollowing
                deriving (FramePos -> FramePos -> Bool
(FramePos -> FramePos -> Bool)
-> (FramePos -> FramePos -> Bool) -> Eq FramePos
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FramePos -> FramePos -> Bool
== :: FramePos -> FramePos -> Bool
$c/= :: FramePos -> FramePos -> Bool
/= :: FramePos -> FramePos -> Bool
Eq,Int -> FramePos -> ShowS
[FramePos] -> ShowS
FramePos -> String
(Int -> FramePos -> ShowS)
-> (FramePos -> String) -> ([FramePos] -> ShowS) -> Show FramePos
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FramePos -> ShowS
showsPrec :: Int -> FramePos -> ShowS
$cshow :: FramePos -> String
show :: FramePos -> String
$cshowList :: [FramePos] -> ShowS
showList :: [FramePos] -> ShowS
Show,ReadPrec [FramePos]
ReadPrec FramePos
Int -> ReadS FramePos
ReadS [FramePos]
(Int -> ReadS FramePos)
-> ReadS [FramePos]
-> ReadPrec FramePos
-> ReadPrec [FramePos]
-> Read FramePos
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FramePos
readsPrec :: Int -> ReadS FramePos
$creadList :: ReadS [FramePos]
readList :: ReadS [FramePos]
$creadPrec :: ReadPrec FramePos
readPrec :: ReadPrec FramePos
$creadListPrec :: ReadPrec [FramePos]
readListPrec :: ReadPrec [FramePos]
Read,Typeable FramePos
Typeable FramePos =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FramePos -> c FramePos)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FramePos)
-> (FramePos -> Constr)
-> (FramePos -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FramePos))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FramePos))
-> ((forall b. Data b => b -> b) -> FramePos -> FramePos)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FramePos -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FramePos -> r)
-> (forall u. (forall d. Data d => d -> u) -> FramePos -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> FramePos -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FramePos -> m FramePos)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FramePos -> m FramePos)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FramePos -> m FramePos)
-> Data FramePos
FramePos -> Constr
FramePos -> DataType
(forall b. Data b => b -> b) -> FramePos -> FramePos
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) -> FramePos -> u
forall u. (forall d. Data d => d -> u) -> FramePos -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FramePos -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FramePos -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FramePos -> m FramePos
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FramePos -> m FramePos
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FramePos
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FramePos -> c FramePos
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FramePos)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FramePos)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FramePos -> c FramePos
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FramePos -> c FramePos
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FramePos
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FramePos
$ctoConstr :: FramePos -> Constr
toConstr :: FramePos -> Constr
$cdataTypeOf :: FramePos -> DataType
dataTypeOf :: FramePos -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FramePos)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FramePos)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FramePos)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FramePos)
$cgmapT :: (forall b. Data b => b -> b) -> FramePos -> FramePos
gmapT :: (forall b. Data b => b -> b) -> FramePos -> FramePos
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FramePos -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FramePos -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FramePos -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FramePos -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FramePos -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FramePos -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FramePos -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FramePos -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FramePos -> m FramePos
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FramePos -> m FramePos
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FramePos -> m FramePos
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FramePos -> m FramePos
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FramePos -> m FramePos
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FramePos -> m FramePos
Data,Typeable)


-- | the type of an odbc literal (e.g. {d '2000-01-01'}),
-- correpsonding to the letter after the opening {
data OdbcLiteralType = OLDate
                     | OLTime
                     | OLTimestamp
                       deriving (OdbcLiteralType -> OdbcLiteralType -> Bool
(OdbcLiteralType -> OdbcLiteralType -> Bool)
-> (OdbcLiteralType -> OdbcLiteralType -> Bool)
-> Eq OdbcLiteralType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OdbcLiteralType -> OdbcLiteralType -> Bool
== :: OdbcLiteralType -> OdbcLiteralType -> Bool
$c/= :: OdbcLiteralType -> OdbcLiteralType -> Bool
/= :: OdbcLiteralType -> OdbcLiteralType -> Bool
Eq,Int -> OdbcLiteralType -> ShowS
[OdbcLiteralType] -> ShowS
OdbcLiteralType -> String
(Int -> OdbcLiteralType -> ShowS)
-> (OdbcLiteralType -> String)
-> ([OdbcLiteralType] -> ShowS)
-> Show OdbcLiteralType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OdbcLiteralType -> ShowS
showsPrec :: Int -> OdbcLiteralType -> ShowS
$cshow :: OdbcLiteralType -> String
show :: OdbcLiteralType -> String
$cshowList :: [OdbcLiteralType] -> ShowS
showList :: [OdbcLiteralType] -> ShowS
Show,ReadPrec [OdbcLiteralType]
ReadPrec OdbcLiteralType
Int -> ReadS OdbcLiteralType
ReadS [OdbcLiteralType]
(Int -> ReadS OdbcLiteralType)
-> ReadS [OdbcLiteralType]
-> ReadPrec OdbcLiteralType
-> ReadPrec [OdbcLiteralType]
-> Read OdbcLiteralType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS OdbcLiteralType
readsPrec :: Int -> ReadS OdbcLiteralType
$creadList :: ReadS [OdbcLiteralType]
readList :: ReadS [OdbcLiteralType]
$creadPrec :: ReadPrec OdbcLiteralType
readPrec :: ReadPrec OdbcLiteralType
$creadListPrec :: ReadPrec [OdbcLiteralType]
readListPrec :: ReadPrec [OdbcLiteralType]
Read,Typeable OdbcLiteralType
Typeable OdbcLiteralType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OdbcLiteralType -> c OdbcLiteralType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OdbcLiteralType)
-> (OdbcLiteralType -> Constr)
-> (OdbcLiteralType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OdbcLiteralType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c OdbcLiteralType))
-> ((forall b. Data b => b -> b)
    -> OdbcLiteralType -> OdbcLiteralType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OdbcLiteralType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OdbcLiteralType -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> OdbcLiteralType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> OdbcLiteralType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> OdbcLiteralType -> m OdbcLiteralType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> OdbcLiteralType -> m OdbcLiteralType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> OdbcLiteralType -> m OdbcLiteralType)
-> Data OdbcLiteralType
OdbcLiteralType -> Constr
OdbcLiteralType -> DataType
(forall b. Data b => b -> b) -> OdbcLiteralType -> OdbcLiteralType
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) -> OdbcLiteralType -> u
forall u. (forall d. Data d => d -> u) -> OdbcLiteralType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OdbcLiteralType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OdbcLiteralType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> OdbcLiteralType -> m OdbcLiteralType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OdbcLiteralType -> m OdbcLiteralType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OdbcLiteralType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OdbcLiteralType -> c OdbcLiteralType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OdbcLiteralType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OdbcLiteralType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OdbcLiteralType -> c OdbcLiteralType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OdbcLiteralType -> c OdbcLiteralType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OdbcLiteralType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OdbcLiteralType
$ctoConstr :: OdbcLiteralType -> Constr
toConstr :: OdbcLiteralType -> Constr
$cdataTypeOf :: OdbcLiteralType -> DataType
dataTypeOf :: OdbcLiteralType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OdbcLiteralType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OdbcLiteralType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OdbcLiteralType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OdbcLiteralType)
$cgmapT :: (forall b. Data b => b -> b) -> OdbcLiteralType -> OdbcLiteralType
gmapT :: (forall b. Data b => b -> b) -> OdbcLiteralType -> OdbcLiteralType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OdbcLiteralType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OdbcLiteralType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OdbcLiteralType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OdbcLiteralType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OdbcLiteralType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> OdbcLiteralType -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> OdbcLiteralType -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> OdbcLiteralType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> OdbcLiteralType -> m OdbcLiteralType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> OdbcLiteralType -> m OdbcLiteralType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OdbcLiteralType -> m OdbcLiteralType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OdbcLiteralType -> m OdbcLiteralType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OdbcLiteralType -> m OdbcLiteralType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OdbcLiteralType -> m OdbcLiteralType
Data,Typeable)


-- | Represents a query expression, which can be:
--
-- * a regular select;
--
-- * a set operator (union, except, intersect);
--
-- * a common table expression (with);
--
-- * a table value constructor (values (1,2),(3,4)); or
--
-- * an explicit table (table t).
data QueryExpr
    = Select
      {QueryExpr -> SetQuantifier
qeSetQuantifier :: SetQuantifier
      ,QueryExpr -> [(ScalarExpr, Maybe Name)]
qeSelectList :: [(ScalarExpr,Maybe Name)]
       -- ^ the expressions and the column aliases

{-
TODO: consider breaking this up. The SQL grammar has
queryexpr = select <select list> [<table expression>]
table expression = <from> [where] [groupby] [having] ...

This would make some things a bit cleaner?
-}

      ,QueryExpr -> [TableRef]
qeFrom :: [TableRef]
      ,QueryExpr -> Maybe ScalarExpr
qeWhere :: Maybe ScalarExpr
      ,QueryExpr -> [GroupingExpr]
qeGroupBy :: [GroupingExpr]
      ,QueryExpr -> Maybe ScalarExpr
qeHaving :: Maybe ScalarExpr
      ,QueryExpr -> [SortSpec]
qeOrderBy :: [SortSpec]
      ,QueryExpr -> Maybe ScalarExpr
qeOffset :: Maybe ScalarExpr
      ,QueryExpr -> Maybe ScalarExpr
qeFetchFirst :: Maybe ScalarExpr
      }
    | QueryExprSetOp
      {QueryExpr -> QueryExpr
qe0 :: QueryExpr
      ,QueryExpr -> SetOperatorName
qeCombOp :: SetOperatorName
      ,qeSetQuantifier :: SetQuantifier
      ,QueryExpr -> Corresponding
qeCorresponding :: Corresponding
      ,QueryExpr -> QueryExpr
qe1 :: QueryExpr
      }
    | With
      {QueryExpr -> Bool
qeWithRecursive :: Bool
      ,QueryExpr -> [(Alias, QueryExpr)]
qeViews :: [(Alias,QueryExpr)]
      ,QueryExpr -> QueryExpr
qeQueryExpression :: QueryExpr}
    | Values [[ScalarExpr]]
    | Table [Name]
    | QEComment [Comment] QueryExpr
      deriving (QueryExpr -> QueryExpr -> Bool
(QueryExpr -> QueryExpr -> Bool)
-> (QueryExpr -> QueryExpr -> Bool) -> Eq QueryExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QueryExpr -> QueryExpr -> Bool
== :: QueryExpr -> QueryExpr -> Bool
$c/= :: QueryExpr -> QueryExpr -> Bool
/= :: QueryExpr -> QueryExpr -> Bool
Eq,Int -> QueryExpr -> ShowS
[QueryExpr] -> ShowS
QueryExpr -> String
(Int -> QueryExpr -> ShowS)
-> (QueryExpr -> String)
-> ([QueryExpr] -> ShowS)
-> Show QueryExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QueryExpr -> ShowS
showsPrec :: Int -> QueryExpr -> ShowS
$cshow :: QueryExpr -> String
show :: QueryExpr -> String
$cshowList :: [QueryExpr] -> ShowS
showList :: [QueryExpr] -> ShowS
Show,ReadPrec [QueryExpr]
ReadPrec QueryExpr
Int -> ReadS QueryExpr
ReadS [QueryExpr]
(Int -> ReadS QueryExpr)
-> ReadS [QueryExpr]
-> ReadPrec QueryExpr
-> ReadPrec [QueryExpr]
-> Read QueryExpr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS QueryExpr
readsPrec :: Int -> ReadS QueryExpr
$creadList :: ReadS [QueryExpr]
readList :: ReadS [QueryExpr]
$creadPrec :: ReadPrec QueryExpr
readPrec :: ReadPrec QueryExpr
$creadListPrec :: ReadPrec [QueryExpr]
readListPrec :: ReadPrec [QueryExpr]
Read,Typeable QueryExpr
Typeable QueryExpr =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> QueryExpr -> c QueryExpr)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c QueryExpr)
-> (QueryExpr -> Constr)
-> (QueryExpr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c QueryExpr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QueryExpr))
-> ((forall b. Data b => b -> b) -> QueryExpr -> QueryExpr)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QueryExpr -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QueryExpr -> r)
-> (forall u. (forall d. Data d => d -> u) -> QueryExpr -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> QueryExpr -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr)
-> Data QueryExpr
QueryExpr -> Constr
QueryExpr -> DataType
(forall b. Data b => b -> b) -> QueryExpr -> QueryExpr
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) -> QueryExpr -> u
forall u. (forall d. Data d => d -> u) -> QueryExpr -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QueryExpr -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QueryExpr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c QueryExpr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QueryExpr -> c QueryExpr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c QueryExpr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QueryExpr)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QueryExpr -> c QueryExpr
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QueryExpr -> c QueryExpr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c QueryExpr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c QueryExpr
$ctoConstr :: QueryExpr -> Constr
toConstr :: QueryExpr -> Constr
$cdataTypeOf :: QueryExpr -> DataType
dataTypeOf :: QueryExpr -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c QueryExpr)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c QueryExpr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QueryExpr)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QueryExpr)
$cgmapT :: (forall b. Data b => b -> b) -> QueryExpr -> QueryExpr
gmapT :: (forall b. Data b => b -> b) -> QueryExpr -> QueryExpr
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QueryExpr -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QueryExpr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QueryExpr -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QueryExpr -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> QueryExpr -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> QueryExpr -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> QueryExpr -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> QueryExpr -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr
Data,Typeable)

{-
TODO: add queryexpr parens to deal with e.g.
(select 1 union select 2) union select 3
I'm not sure if this is valid syntax or not.
-}

-- | Represents the Distinct or All keywords, which can be used
-- before a select list, in an aggregate/window function
-- application, or in a query expression set operator.
data SetQuantifier = SQDefault | Distinct | All deriving (SetQuantifier -> SetQuantifier -> Bool
(SetQuantifier -> SetQuantifier -> Bool)
-> (SetQuantifier -> SetQuantifier -> Bool) -> Eq SetQuantifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SetQuantifier -> SetQuantifier -> Bool
== :: SetQuantifier -> SetQuantifier -> Bool
$c/= :: SetQuantifier -> SetQuantifier -> Bool
/= :: SetQuantifier -> SetQuantifier -> Bool
Eq,Int -> SetQuantifier -> ShowS
[SetQuantifier] -> ShowS
SetQuantifier -> String
(Int -> SetQuantifier -> ShowS)
-> (SetQuantifier -> String)
-> ([SetQuantifier] -> ShowS)
-> Show SetQuantifier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SetQuantifier -> ShowS
showsPrec :: Int -> SetQuantifier -> ShowS
$cshow :: SetQuantifier -> String
show :: SetQuantifier -> String
$cshowList :: [SetQuantifier] -> ShowS
showList :: [SetQuantifier] -> ShowS
Show,ReadPrec [SetQuantifier]
ReadPrec SetQuantifier
Int -> ReadS SetQuantifier
ReadS [SetQuantifier]
(Int -> ReadS SetQuantifier)
-> ReadS [SetQuantifier]
-> ReadPrec SetQuantifier
-> ReadPrec [SetQuantifier]
-> Read SetQuantifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SetQuantifier
readsPrec :: Int -> ReadS SetQuantifier
$creadList :: ReadS [SetQuantifier]
readList :: ReadS [SetQuantifier]
$creadPrec :: ReadPrec SetQuantifier
readPrec :: ReadPrec SetQuantifier
$creadListPrec :: ReadPrec [SetQuantifier]
readListPrec :: ReadPrec [SetQuantifier]
Read,Typeable SetQuantifier
Typeable SetQuantifier =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SetQuantifier -> c SetQuantifier)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SetQuantifier)
-> (SetQuantifier -> Constr)
-> (SetQuantifier -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SetQuantifier))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SetQuantifier))
-> ((forall b. Data b => b -> b) -> SetQuantifier -> SetQuantifier)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SetQuantifier -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SetQuantifier -> r)
-> (forall u. (forall d. Data d => d -> u) -> SetQuantifier -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SetQuantifier -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier)
-> Data SetQuantifier
SetQuantifier -> Constr
SetQuantifier -> DataType
(forall b. Data b => b -> b) -> SetQuantifier -> SetQuantifier
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) -> SetQuantifier -> u
forall u. (forall d. Data d => d -> u) -> SetQuantifier -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SetQuantifier -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SetQuantifier -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetQuantifier
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetQuantifier -> c SetQuantifier
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SetQuantifier)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SetQuantifier)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetQuantifier -> c SetQuantifier
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetQuantifier -> c SetQuantifier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetQuantifier
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetQuantifier
$ctoConstr :: SetQuantifier -> Constr
toConstr :: SetQuantifier -> Constr
$cdataTypeOf :: SetQuantifier -> DataType
dataTypeOf :: SetQuantifier -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SetQuantifier)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SetQuantifier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SetQuantifier)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SetQuantifier)
$cgmapT :: (forall b. Data b => b -> b) -> SetQuantifier -> SetQuantifier
gmapT :: (forall b. Data b => b -> b) -> SetQuantifier -> SetQuantifier
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SetQuantifier -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SetQuantifier -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SetQuantifier -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SetQuantifier -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SetQuantifier -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SetQuantifier -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SetQuantifier -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SetQuantifier -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier
Data,Typeable)

-- | The direction for a column in order by.
data Direction = DirDefault | Asc | Desc deriving (Direction -> Direction -> Bool
(Direction -> Direction -> Bool)
-> (Direction -> Direction -> Bool) -> Eq Direction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Direction -> Direction -> Bool
== :: Direction -> Direction -> Bool
$c/= :: Direction -> Direction -> Bool
/= :: Direction -> Direction -> Bool
Eq,Int -> Direction -> ShowS
[Direction] -> ShowS
Direction -> String
(Int -> Direction -> ShowS)
-> (Direction -> String)
-> ([Direction] -> ShowS)
-> Show Direction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Direction -> ShowS
showsPrec :: Int -> Direction -> ShowS
$cshow :: Direction -> String
show :: Direction -> String
$cshowList :: [Direction] -> ShowS
showList :: [Direction] -> ShowS
Show,ReadPrec [Direction]
ReadPrec Direction
Int -> ReadS Direction
ReadS [Direction]
(Int -> ReadS Direction)
-> ReadS [Direction]
-> ReadPrec Direction
-> ReadPrec [Direction]
-> Read Direction
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Direction
readsPrec :: Int -> ReadS Direction
$creadList :: ReadS [Direction]
readList :: ReadS [Direction]
$creadPrec :: ReadPrec Direction
readPrec :: ReadPrec Direction
$creadListPrec :: ReadPrec [Direction]
readListPrec :: ReadPrec [Direction]
Read,Typeable Direction
Typeable Direction =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Direction -> c Direction)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Direction)
-> (Direction -> Constr)
-> (Direction -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Direction))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Direction))
-> ((forall b. Data b => b -> b) -> Direction -> Direction)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Direction -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Direction -> r)
-> (forall u. (forall d. Data d => d -> u) -> Direction -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Direction -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Direction -> m Direction)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Direction -> m Direction)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Direction -> m Direction)
-> Data Direction
Direction -> Constr
Direction -> DataType
(forall b. Data b => b -> b) -> Direction -> Direction
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) -> Direction -> u
forall u. (forall d. Data d => d -> u) -> Direction -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Direction -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Direction -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Direction -> m Direction
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Direction -> m Direction
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Direction
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Direction -> c Direction
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Direction)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Direction)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Direction -> c Direction
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Direction -> c Direction
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Direction
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Direction
$ctoConstr :: Direction -> Constr
toConstr :: Direction -> Constr
$cdataTypeOf :: Direction -> DataType
dataTypeOf :: Direction -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Direction)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Direction)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Direction)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Direction)
$cgmapT :: (forall b. Data b => b -> b) -> Direction -> Direction
gmapT :: (forall b. Data b => b -> b) -> Direction -> Direction
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Direction -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Direction -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Direction -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Direction -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Direction -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Direction -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Direction -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Direction -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Direction -> m Direction
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Direction -> m Direction
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Direction -> m Direction
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Direction -> m Direction
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Direction -> m Direction
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Direction -> m Direction
Data,Typeable)
-- | Query expression set operators.
data SetOperatorName = Union | Except | Intersect deriving (SetOperatorName -> SetOperatorName -> Bool
(SetOperatorName -> SetOperatorName -> Bool)
-> (SetOperatorName -> SetOperatorName -> Bool)
-> Eq SetOperatorName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SetOperatorName -> SetOperatorName -> Bool
== :: SetOperatorName -> SetOperatorName -> Bool
$c/= :: SetOperatorName -> SetOperatorName -> Bool
/= :: SetOperatorName -> SetOperatorName -> Bool
Eq,Int -> SetOperatorName -> ShowS
[SetOperatorName] -> ShowS
SetOperatorName -> String
(Int -> SetOperatorName -> ShowS)
-> (SetOperatorName -> String)
-> ([SetOperatorName] -> ShowS)
-> Show SetOperatorName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SetOperatorName -> ShowS
showsPrec :: Int -> SetOperatorName -> ShowS
$cshow :: SetOperatorName -> String
show :: SetOperatorName -> String
$cshowList :: [SetOperatorName] -> ShowS
showList :: [SetOperatorName] -> ShowS
Show,ReadPrec [SetOperatorName]
ReadPrec SetOperatorName
Int -> ReadS SetOperatorName
ReadS [SetOperatorName]
(Int -> ReadS SetOperatorName)
-> ReadS [SetOperatorName]
-> ReadPrec SetOperatorName
-> ReadPrec [SetOperatorName]
-> Read SetOperatorName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SetOperatorName
readsPrec :: Int -> ReadS SetOperatorName
$creadList :: ReadS [SetOperatorName]
readList :: ReadS [SetOperatorName]
$creadPrec :: ReadPrec SetOperatorName
readPrec :: ReadPrec SetOperatorName
$creadListPrec :: ReadPrec [SetOperatorName]
readListPrec :: ReadPrec [SetOperatorName]
Read,Typeable SetOperatorName
Typeable SetOperatorName =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SetOperatorName -> c SetOperatorName)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SetOperatorName)
-> (SetOperatorName -> Constr)
-> (SetOperatorName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SetOperatorName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SetOperatorName))
-> ((forall b. Data b => b -> b)
    -> SetOperatorName -> SetOperatorName)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SetOperatorName -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SetOperatorName -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SetOperatorName -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SetOperatorName -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SetOperatorName -> m SetOperatorName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SetOperatorName -> m SetOperatorName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SetOperatorName -> m SetOperatorName)
-> Data SetOperatorName
SetOperatorName -> Constr
SetOperatorName -> DataType
(forall b. Data b => b -> b) -> SetOperatorName -> SetOperatorName
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) -> SetOperatorName -> u
forall u. (forall d. Data d => d -> u) -> SetOperatorName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SetOperatorName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SetOperatorName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SetOperatorName -> m SetOperatorName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SetOperatorName -> m SetOperatorName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetOperatorName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetOperatorName -> c SetOperatorName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SetOperatorName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SetOperatorName)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetOperatorName -> c SetOperatorName
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetOperatorName -> c SetOperatorName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetOperatorName
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetOperatorName
$ctoConstr :: SetOperatorName -> Constr
toConstr :: SetOperatorName -> Constr
$cdataTypeOf :: SetOperatorName -> DataType
dataTypeOf :: SetOperatorName -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SetOperatorName)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SetOperatorName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SetOperatorName)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SetOperatorName)
$cgmapT :: (forall b. Data b => b -> b) -> SetOperatorName -> SetOperatorName
gmapT :: (forall b. Data b => b -> b) -> SetOperatorName -> SetOperatorName
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SetOperatorName -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SetOperatorName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SetOperatorName -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SetOperatorName -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SetOperatorName -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SetOperatorName -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SetOperatorName -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SetOperatorName -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SetOperatorName -> m SetOperatorName
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SetOperatorName -> m SetOperatorName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SetOperatorName -> m SetOperatorName
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SetOperatorName -> m SetOperatorName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SetOperatorName -> m SetOperatorName
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SetOperatorName -> m SetOperatorName
Data,Typeable)
-- | Corresponding, an option for the set operators.
data Corresponding = Corresponding | Respectively deriving (Corresponding -> Corresponding -> Bool
(Corresponding -> Corresponding -> Bool)
-> (Corresponding -> Corresponding -> Bool) -> Eq Corresponding
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Corresponding -> Corresponding -> Bool
== :: Corresponding -> Corresponding -> Bool
$c/= :: Corresponding -> Corresponding -> Bool
/= :: Corresponding -> Corresponding -> Bool
Eq,Int -> Corresponding -> ShowS
[Corresponding] -> ShowS
Corresponding -> String
(Int -> Corresponding -> ShowS)
-> (Corresponding -> String)
-> ([Corresponding] -> ShowS)
-> Show Corresponding
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Corresponding -> ShowS
showsPrec :: Int -> Corresponding -> ShowS
$cshow :: Corresponding -> String
show :: Corresponding -> String
$cshowList :: [Corresponding] -> ShowS
showList :: [Corresponding] -> ShowS
Show,ReadPrec [Corresponding]
ReadPrec Corresponding
Int -> ReadS Corresponding
ReadS [Corresponding]
(Int -> ReadS Corresponding)
-> ReadS [Corresponding]
-> ReadPrec Corresponding
-> ReadPrec [Corresponding]
-> Read Corresponding
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Corresponding
readsPrec :: Int -> ReadS Corresponding
$creadList :: ReadS [Corresponding]
readList :: ReadS [Corresponding]
$creadPrec :: ReadPrec Corresponding
readPrec :: ReadPrec Corresponding
$creadListPrec :: ReadPrec [Corresponding]
readListPrec :: ReadPrec [Corresponding]
Read,Typeable Corresponding
Typeable Corresponding =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Corresponding -> c Corresponding)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Corresponding)
-> (Corresponding -> Constr)
-> (Corresponding -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Corresponding))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Corresponding))
-> ((forall b. Data b => b -> b) -> Corresponding -> Corresponding)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Corresponding -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Corresponding -> r)
-> (forall u. (forall d. Data d => d -> u) -> Corresponding -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Corresponding -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Corresponding -> m Corresponding)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Corresponding -> m Corresponding)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Corresponding -> m Corresponding)
-> Data Corresponding
Corresponding -> Constr
Corresponding -> DataType
(forall b. Data b => b -> b) -> Corresponding -> Corresponding
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) -> Corresponding -> u
forall u. (forall d. Data d => d -> u) -> Corresponding -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Corresponding -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Corresponding -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Corresponding -> m Corresponding
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Corresponding -> m Corresponding
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Corresponding
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Corresponding -> c Corresponding
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Corresponding)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Corresponding)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Corresponding -> c Corresponding
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Corresponding -> c Corresponding
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Corresponding
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Corresponding
$ctoConstr :: Corresponding -> Constr
toConstr :: Corresponding -> Constr
$cdataTypeOf :: Corresponding -> DataType
dataTypeOf :: Corresponding -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Corresponding)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Corresponding)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Corresponding)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Corresponding)
$cgmapT :: (forall b. Data b => b -> b) -> Corresponding -> Corresponding
gmapT :: (forall b. Data b => b -> b) -> Corresponding -> Corresponding
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Corresponding -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Corresponding -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Corresponding -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Corresponding -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Corresponding -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Corresponding -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Corresponding -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Corresponding -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Corresponding -> m Corresponding
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Corresponding -> m Corresponding
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Corresponding -> m Corresponding
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Corresponding -> m Corresponding
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Corresponding -> m Corresponding
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Corresponding -> m Corresponding
Data,Typeable)

-- | Represents an item in a group by clause.
data GroupingExpr
    = GroupingParens [GroupingExpr]
    | Cube [GroupingExpr]
    | Rollup [GroupingExpr]
    | GroupingSets [GroupingExpr]
    | SimpleGroup ScalarExpr
      deriving (GroupingExpr -> GroupingExpr -> Bool
(GroupingExpr -> GroupingExpr -> Bool)
-> (GroupingExpr -> GroupingExpr -> Bool) -> Eq GroupingExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GroupingExpr -> GroupingExpr -> Bool
== :: GroupingExpr -> GroupingExpr -> Bool
$c/= :: GroupingExpr -> GroupingExpr -> Bool
/= :: GroupingExpr -> GroupingExpr -> Bool
Eq,Int -> GroupingExpr -> ShowS
[GroupingExpr] -> ShowS
GroupingExpr -> String
(Int -> GroupingExpr -> ShowS)
-> (GroupingExpr -> String)
-> ([GroupingExpr] -> ShowS)
-> Show GroupingExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GroupingExpr -> ShowS
showsPrec :: Int -> GroupingExpr -> ShowS
$cshow :: GroupingExpr -> String
show :: GroupingExpr -> String
$cshowList :: [GroupingExpr] -> ShowS
showList :: [GroupingExpr] -> ShowS
Show,ReadPrec [GroupingExpr]
ReadPrec GroupingExpr
Int -> ReadS GroupingExpr
ReadS [GroupingExpr]
(Int -> ReadS GroupingExpr)
-> ReadS [GroupingExpr]
-> ReadPrec GroupingExpr
-> ReadPrec [GroupingExpr]
-> Read GroupingExpr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS GroupingExpr
readsPrec :: Int -> ReadS GroupingExpr
$creadList :: ReadS [GroupingExpr]
readList :: ReadS [GroupingExpr]
$creadPrec :: ReadPrec GroupingExpr
readPrec :: ReadPrec GroupingExpr
$creadListPrec :: ReadPrec [GroupingExpr]
readListPrec :: ReadPrec [GroupingExpr]
Read,Typeable GroupingExpr
Typeable GroupingExpr =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GroupingExpr -> c GroupingExpr)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GroupingExpr)
-> (GroupingExpr -> Constr)
-> (GroupingExpr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GroupingExpr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GroupingExpr))
-> ((forall b. Data b => b -> b) -> GroupingExpr -> GroupingExpr)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GroupingExpr -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GroupingExpr -> r)
-> (forall u. (forall d. Data d => d -> u) -> GroupingExpr -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GroupingExpr -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr)
-> Data GroupingExpr
GroupingExpr -> Constr
GroupingExpr -> DataType
(forall b. Data b => b -> b) -> GroupingExpr -> GroupingExpr
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) -> GroupingExpr -> u
forall u. (forall d. Data d => d -> u) -> GroupingExpr -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GroupingExpr -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GroupingExpr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GroupingExpr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GroupingExpr -> c GroupingExpr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GroupingExpr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GroupingExpr)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GroupingExpr -> c GroupingExpr
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GroupingExpr -> c GroupingExpr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GroupingExpr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GroupingExpr
$ctoConstr :: GroupingExpr -> Constr
toConstr :: GroupingExpr -> Constr
$cdataTypeOf :: GroupingExpr -> DataType
dataTypeOf :: GroupingExpr -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GroupingExpr)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GroupingExpr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GroupingExpr)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GroupingExpr)
$cgmapT :: (forall b. Data b => b -> b) -> GroupingExpr -> GroupingExpr
gmapT :: (forall b. Data b => b -> b) -> GroupingExpr -> GroupingExpr
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GroupingExpr -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GroupingExpr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GroupingExpr -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GroupingExpr -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GroupingExpr -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GroupingExpr -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GroupingExpr -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GroupingExpr -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr
Data,Typeable)

-- | Represents a entry in the csv of tables in the from clause.
data TableRef = -- | from t / from s.t
                TRSimple [Name]
                -- | from a join b, the bool is true if natural was used
              | TRJoin TableRef Bool JoinType TableRef (Maybe JoinCondition)
                -- | from (a)
              | TRParens TableRef
                -- | from a as b(c,d)
              | TRAlias TableRef Alias
                -- | from (query expr)
              | TRQueryExpr QueryExpr
                -- | from function(args)
              | TRFunction [Name] [ScalarExpr]
                -- | from lateral t
              | TRLateral TableRef
                -- | ODBC {oj t1 left outer join t2 on expr} syntax
              | TROdbc TableRef
                deriving (TableRef -> TableRef -> Bool
(TableRef -> TableRef -> Bool)
-> (TableRef -> TableRef -> Bool) -> Eq TableRef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TableRef -> TableRef -> Bool
== :: TableRef -> TableRef -> Bool
$c/= :: TableRef -> TableRef -> Bool
/= :: TableRef -> TableRef -> Bool
Eq,Int -> TableRef -> ShowS
[TableRef] -> ShowS
TableRef -> String
(Int -> TableRef -> ShowS)
-> (TableRef -> String) -> ([TableRef] -> ShowS) -> Show TableRef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TableRef -> ShowS
showsPrec :: Int -> TableRef -> ShowS
$cshow :: TableRef -> String
show :: TableRef -> String
$cshowList :: [TableRef] -> ShowS
showList :: [TableRef] -> ShowS
Show,ReadPrec [TableRef]
ReadPrec TableRef
Int -> ReadS TableRef
ReadS [TableRef]
(Int -> ReadS TableRef)
-> ReadS [TableRef]
-> ReadPrec TableRef
-> ReadPrec [TableRef]
-> Read TableRef
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TableRef
readsPrec :: Int -> ReadS TableRef
$creadList :: ReadS [TableRef]
readList :: ReadS [TableRef]
$creadPrec :: ReadPrec TableRef
readPrec :: ReadPrec TableRef
$creadListPrec :: ReadPrec [TableRef]
readListPrec :: ReadPrec [TableRef]
Read,Typeable TableRef
Typeable TableRef =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TableRef -> c TableRef)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableRef)
-> (TableRef -> Constr)
-> (TableRef -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableRef))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableRef))
-> ((forall b. Data b => b -> b) -> TableRef -> TableRef)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableRef -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableRef -> r)
-> (forall u. (forall d. Data d => d -> u) -> TableRef -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TableRef -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TableRef -> m TableRef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableRef -> m TableRef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableRef -> m TableRef)
-> Data TableRef
TableRef -> Constr
TableRef -> DataType
(forall b. Data b => b -> b) -> TableRef -> TableRef
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) -> TableRef -> u
forall u. (forall d. Data d => d -> u) -> TableRef -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TableRef -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TableRef -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TableRef -> m TableRef
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TableRef -> m TableRef
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TableRef
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableRef -> c TableRef
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TableRef)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableRef)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableRef -> c TableRef
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableRef -> c TableRef
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TableRef
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TableRef
$ctoConstr :: TableRef -> Constr
toConstr :: TableRef -> Constr
$cdataTypeOf :: TableRef -> DataType
dataTypeOf :: TableRef -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TableRef)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TableRef)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableRef)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableRef)
$cgmapT :: (forall b. Data b => b -> b) -> TableRef -> TableRef
gmapT :: (forall b. Data b => b -> b) -> TableRef -> TableRef
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TableRef -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TableRef -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TableRef -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TableRef -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TableRef -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TableRef -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TableRef -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TableRef -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TableRef -> m TableRef
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TableRef -> m TableRef
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TableRef -> m TableRef
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TableRef -> m TableRef
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TableRef -> m TableRef
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TableRef -> m TableRef
Data,Typeable)

-- | Represents an alias for a table valued expression, used in with
-- queries and in from alias, e.g. select a from t u, select a from t u(b),
-- with a(c) as select 1, select * from a.
data Alias = Alias Name (Maybe [Name])
             deriving (Alias -> Alias -> Bool
(Alias -> Alias -> Bool) -> (Alias -> Alias -> Bool) -> Eq Alias
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Alias -> Alias -> Bool
== :: Alias -> Alias -> Bool
$c/= :: Alias -> Alias -> Bool
/= :: Alias -> Alias -> Bool
Eq,Int -> Alias -> ShowS
[Alias] -> ShowS
Alias -> String
(Int -> Alias -> ShowS)
-> (Alias -> String) -> ([Alias] -> ShowS) -> Show Alias
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Alias -> ShowS
showsPrec :: Int -> Alias -> ShowS
$cshow :: Alias -> String
show :: Alias -> String
$cshowList :: [Alias] -> ShowS
showList :: [Alias] -> ShowS
Show,ReadPrec [Alias]
ReadPrec Alias
Int -> ReadS Alias
ReadS [Alias]
(Int -> ReadS Alias)
-> ReadS [Alias]
-> ReadPrec Alias
-> ReadPrec [Alias]
-> Read Alias
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Alias
readsPrec :: Int -> ReadS Alias
$creadList :: ReadS [Alias]
readList :: ReadS [Alias]
$creadPrec :: ReadPrec Alias
readPrec :: ReadPrec Alias
$creadListPrec :: ReadPrec [Alias]
readListPrec :: ReadPrec [Alias]
Read,Typeable Alias
Typeable Alias =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Alias -> c Alias)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Alias)
-> (Alias -> Constr)
-> (Alias -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Alias))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alias))
-> ((forall b. Data b => b -> b) -> Alias -> Alias)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alias -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alias -> r)
-> (forall u. (forall d. Data d => d -> u) -> Alias -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Alias -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Alias -> m Alias)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Alias -> m Alias)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Alias -> m Alias)
-> Data Alias
Alias -> Constr
Alias -> DataType
(forall b. Data b => b -> b) -> Alias -> Alias
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) -> Alias -> u
forall u. (forall d. Data d => d -> u) -> Alias -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alias -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alias -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Alias -> m Alias
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Alias -> m Alias
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Alias
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alias -> c Alias
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Alias)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alias)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alias -> c Alias
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alias -> c Alias
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Alias
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Alias
$ctoConstr :: Alias -> Constr
toConstr :: Alias -> Constr
$cdataTypeOf :: Alias -> DataType
dataTypeOf :: Alias -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Alias)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Alias)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alias)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alias)
$cgmapT :: (forall b. Data b => b -> b) -> Alias -> Alias
gmapT :: (forall b. Data b => b -> b) -> Alias -> Alias
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alias -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alias -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alias -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alias -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Alias -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Alias -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Alias -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Alias -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Alias -> m Alias
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Alias -> m Alias
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Alias -> m Alias
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Alias -> m Alias
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Alias -> m Alias
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Alias -> m Alias
Data,Typeable)

-- | The type of a join.
data JoinType = JInner | JLeft | JRight | JFull | JCross
                deriving (JoinType -> JoinType -> Bool
(JoinType -> JoinType -> Bool)
-> (JoinType -> JoinType -> Bool) -> Eq JoinType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JoinType -> JoinType -> Bool
== :: JoinType -> JoinType -> Bool
$c/= :: JoinType -> JoinType -> Bool
/= :: JoinType -> JoinType -> Bool
Eq,Int -> JoinType -> ShowS
[JoinType] -> ShowS
JoinType -> String
(Int -> JoinType -> ShowS)
-> (JoinType -> String) -> ([JoinType] -> ShowS) -> Show JoinType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JoinType -> ShowS
showsPrec :: Int -> JoinType -> ShowS
$cshow :: JoinType -> String
show :: JoinType -> String
$cshowList :: [JoinType] -> ShowS
showList :: [JoinType] -> ShowS
Show,ReadPrec [JoinType]
ReadPrec JoinType
Int -> ReadS JoinType
ReadS [JoinType]
(Int -> ReadS JoinType)
-> ReadS [JoinType]
-> ReadPrec JoinType
-> ReadPrec [JoinType]
-> Read JoinType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS JoinType
readsPrec :: Int -> ReadS JoinType
$creadList :: ReadS [JoinType]
readList :: ReadS [JoinType]
$creadPrec :: ReadPrec JoinType
readPrec :: ReadPrec JoinType
$creadListPrec :: ReadPrec [JoinType]
readListPrec :: ReadPrec [JoinType]
Read,Typeable JoinType
Typeable JoinType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> JoinType -> c JoinType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c JoinType)
-> (JoinType -> Constr)
-> (JoinType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c JoinType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinType))
-> ((forall b. Data b => b -> b) -> JoinType -> JoinType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> JoinType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> JoinType -> r)
-> (forall u. (forall d. Data d => d -> u) -> JoinType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> JoinType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> JoinType -> m JoinType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> JoinType -> m JoinType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> JoinType -> m JoinType)
-> Data JoinType
JoinType -> Constr
JoinType -> DataType
(forall b. Data b => b -> b) -> JoinType -> JoinType
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) -> JoinType -> u
forall u. (forall d. Data d => d -> u) -> JoinType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoinType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JoinType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> JoinType -> m JoinType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JoinType -> m JoinType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoinType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoinType -> c JoinType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JoinType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoinType -> c JoinType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoinType -> c JoinType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoinType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoinType
$ctoConstr :: JoinType -> Constr
toConstr :: JoinType -> Constr
$cdataTypeOf :: JoinType -> DataType
dataTypeOf :: JoinType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JoinType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JoinType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinType)
$cgmapT :: (forall b. Data b => b -> b) -> JoinType -> JoinType
gmapT :: (forall b. Data b => b -> b) -> JoinType -> JoinType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoinType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoinType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JoinType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JoinType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> JoinType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> JoinType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> JoinType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> JoinType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> JoinType -> m JoinType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> JoinType -> m JoinType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JoinType -> m JoinType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JoinType -> m JoinType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JoinType -> m JoinType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JoinType -> m JoinType
Data,Typeable)

-- | The join condition.
data JoinCondition = JoinOn ScalarExpr -- ^ on expr
                   | JoinUsing [Name] -- ^ using (column list)
                     deriving (JoinCondition -> JoinCondition -> Bool
(JoinCondition -> JoinCondition -> Bool)
-> (JoinCondition -> JoinCondition -> Bool) -> Eq JoinCondition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JoinCondition -> JoinCondition -> Bool
== :: JoinCondition -> JoinCondition -> Bool
$c/= :: JoinCondition -> JoinCondition -> Bool
/= :: JoinCondition -> JoinCondition -> Bool
Eq,Int -> JoinCondition -> ShowS
[JoinCondition] -> ShowS
JoinCondition -> String
(Int -> JoinCondition -> ShowS)
-> (JoinCondition -> String)
-> ([JoinCondition] -> ShowS)
-> Show JoinCondition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JoinCondition -> ShowS
showsPrec :: Int -> JoinCondition -> ShowS
$cshow :: JoinCondition -> String
show :: JoinCondition -> String
$cshowList :: [JoinCondition] -> ShowS
showList :: [JoinCondition] -> ShowS
Show,ReadPrec [JoinCondition]
ReadPrec JoinCondition
Int -> ReadS JoinCondition
ReadS [JoinCondition]
(Int -> ReadS JoinCondition)
-> ReadS [JoinCondition]
-> ReadPrec JoinCondition
-> ReadPrec [JoinCondition]
-> Read JoinCondition
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS JoinCondition
readsPrec :: Int -> ReadS JoinCondition
$creadList :: ReadS [JoinCondition]
readList :: ReadS [JoinCondition]
$creadPrec :: ReadPrec JoinCondition
readPrec :: ReadPrec JoinCondition
$creadListPrec :: ReadPrec [JoinCondition]
readListPrec :: ReadPrec [JoinCondition]
Read,Typeable JoinCondition
Typeable JoinCondition =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> JoinCondition -> c JoinCondition)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c JoinCondition)
-> (JoinCondition -> Constr)
-> (JoinCondition -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c JoinCondition))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c JoinCondition))
-> ((forall b. Data b => b -> b) -> JoinCondition -> JoinCondition)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> JoinCondition -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> JoinCondition -> r)
-> (forall u. (forall d. Data d => d -> u) -> JoinCondition -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> JoinCondition -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition)
-> Data JoinCondition
JoinCondition -> Constr
JoinCondition -> DataType
(forall b. Data b => b -> b) -> JoinCondition -> JoinCondition
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) -> JoinCondition -> u
forall u. (forall d. Data d => d -> u) -> JoinCondition -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoinCondition -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JoinCondition -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoinCondition
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoinCondition -> c JoinCondition
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JoinCondition)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c JoinCondition)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoinCondition -> c JoinCondition
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoinCondition -> c JoinCondition
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoinCondition
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoinCondition
$ctoConstr :: JoinCondition -> Constr
toConstr :: JoinCondition -> Constr
$cdataTypeOf :: JoinCondition -> DataType
dataTypeOf :: JoinCondition -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JoinCondition)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JoinCondition)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c JoinCondition)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c JoinCondition)
$cgmapT :: (forall b. Data b => b -> b) -> JoinCondition -> JoinCondition
gmapT :: (forall b. Data b => b -> b) -> JoinCondition -> JoinCondition
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoinCondition -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoinCondition -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JoinCondition -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JoinCondition -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> JoinCondition -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> JoinCondition -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> JoinCondition -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> JoinCondition -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition
Data,Typeable)

-- ---------------------------

data Statement =
    -- ddl
    CreateSchema [Name]
  | DropSchema [Name] DropBehaviour
  | CreateTable [Name] [TableElement]
  | AlterTable [Name] AlterTableAction
  | DropTable [Name] DropBehaviour
  | CreateIndex Bool [Name] [Name] [Name]
  | CreateView Bool [Name] (Maybe [Name])
        QueryExpr (Maybe CheckOption)
  | DropView [Name]  DropBehaviour
  | CreateDomain [Name] TypeName (Maybe ScalarExpr)
       [(Maybe [Name], ScalarExpr)]
  | AlterDomain [Name] AlterDomainAction
  | DropDomain [Name] DropBehaviour

    -- probably won't do character sets, collations
    -- and translations because I think they are too far from
    -- reality
  {-  | CreateCharacterSet
  | DropCharacterSet
  | CreateCollation
  | DropCollation
  | CreateTranslation
  | DropTranslation -}
  | CreateAssertion [Name] ScalarExpr
  | DropAssertion [Name] DropBehaviour
  {-   | CreateTrigger
  | DropTrigger
  | CreateType
  | AlterType
  | DropType
    -- routine stuff? TODO
  | CreateCast
  | DropCast
  | CreateOrdering
  | DropOrdering -}
    -- transforms
  | CreateSequence [Name] [SequenceGeneratorOption]
  | AlterSequence [Name] [SequenceGeneratorOption]
  | DropSequence [Name] DropBehaviour
    -- dml
  | SelectStatement QueryExpr
  {-    | DeclareCursor
  | OpenCursor
  | FetchCursor
  | CloseCursor
  | SelectInto -}
  --   | DeletePositioned
  | Delete [Name] (Maybe Name) (Maybe ScalarExpr)
  | Truncate [Name] IdentityRestart
  | Insert [Name] (Maybe [Name]) InsertSource
  --  | Merge
  | Update [Name] (Maybe Name) [SetClause] (Maybe ScalarExpr)
  {-  | TemporaryTable
  | FreeLocator
  | HoldLocator  -}
    -- access control
  | GrantPrivilege [PrivilegeAction] PrivilegeObject [Name] GrantOption
  | GrantRole [Name] [Name] AdminOption
  | CreateRole Name
  | DropRole Name
  | RevokePrivilege GrantOptionFor [PrivilegeAction] PrivilegeObject
            [Name] DropBehaviour
  | RevokeRole AdminOptionFor [Name] [Name] DropBehaviour
    -- transaction management
  | StartTransaction
  --  | SetTransaction
  --  | SetContraints
  | Savepoint Name
  | ReleaseSavepoint Name
  | Commit
  | Rollback (Maybe Name)
    -- session
  {-  | SetSessionCharacteristics
  | SetSessionAuthorization
  | SetRole
  | SetTimeZone
  | SetCatalog
  | SetSchema
  | SetNames
  | SetTransform
  | SetCollation -}
  | StatementComment [Comment]
  | EmptyStatement
    deriving (Statement -> Statement -> Bool
(Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool) -> Eq Statement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Statement -> Statement -> Bool
== :: Statement -> Statement -> Bool
$c/= :: Statement -> Statement -> Bool
/= :: Statement -> Statement -> Bool
Eq,Int -> Statement -> ShowS
[Statement] -> ShowS
Statement -> String
(Int -> Statement -> ShowS)
-> (Statement -> String)
-> ([Statement] -> ShowS)
-> Show Statement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Statement -> ShowS
showsPrec :: Int -> Statement -> ShowS
$cshow :: Statement -> String
show :: Statement -> String
$cshowList :: [Statement] -> ShowS
showList :: [Statement] -> ShowS
Show,ReadPrec [Statement]
ReadPrec Statement
Int -> ReadS Statement
ReadS [Statement]
(Int -> ReadS Statement)
-> ReadS [Statement]
-> ReadPrec Statement
-> ReadPrec [Statement]
-> Read Statement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Statement
readsPrec :: Int -> ReadS Statement
$creadList :: ReadS [Statement]
readList :: ReadS [Statement]
$creadPrec :: ReadPrec Statement
readPrec :: ReadPrec Statement
$creadListPrec :: ReadPrec [Statement]
readListPrec :: ReadPrec [Statement]
Read,Typeable Statement
Typeable Statement =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Statement -> c Statement)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Statement)
-> (Statement -> Constr)
-> (Statement -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Statement))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement))
-> ((forall b. Data b => b -> b) -> Statement -> Statement)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement -> r)
-> (forall u. (forall d. Data d => d -> u) -> Statement -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Statement -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Statement -> m Statement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement -> m Statement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement -> m Statement)
-> Data Statement
Statement -> Constr
Statement -> DataType
(forall b. Data b => b -> b) -> Statement -> Statement
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) -> Statement -> u
forall u. (forall d. Data d => d -> u) -> Statement -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Statement)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
$ctoConstr :: Statement -> Constr
toConstr :: Statement -> Constr
$cdataTypeOf :: Statement -> DataType
dataTypeOf :: Statement -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Statement)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Statement)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement)
$cgmapT :: (forall b. Data b => b -> b) -> Statement -> Statement
gmapT :: (forall b. Data b => b -> b) -> Statement -> Statement
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Statement -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Statement -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Statement -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Statement -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
Data,Typeable)

data DropBehaviour =
    Restrict
  | Cascade
  | DefaultDropBehaviour
    deriving (DropBehaviour -> DropBehaviour -> Bool
(DropBehaviour -> DropBehaviour -> Bool)
-> (DropBehaviour -> DropBehaviour -> Bool) -> Eq DropBehaviour
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DropBehaviour -> DropBehaviour -> Bool
== :: DropBehaviour -> DropBehaviour -> Bool
$c/= :: DropBehaviour -> DropBehaviour -> Bool
/= :: DropBehaviour -> DropBehaviour -> Bool
Eq,Int -> DropBehaviour -> ShowS
[DropBehaviour] -> ShowS
DropBehaviour -> String
(Int -> DropBehaviour -> ShowS)
-> (DropBehaviour -> String)
-> ([DropBehaviour] -> ShowS)
-> Show DropBehaviour
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DropBehaviour -> ShowS
showsPrec :: Int -> DropBehaviour -> ShowS
$cshow :: DropBehaviour -> String
show :: DropBehaviour -> String
$cshowList :: [DropBehaviour] -> ShowS
showList :: [DropBehaviour] -> ShowS
Show,ReadPrec [DropBehaviour]
ReadPrec DropBehaviour
Int -> ReadS DropBehaviour
ReadS [DropBehaviour]
(Int -> ReadS DropBehaviour)
-> ReadS [DropBehaviour]
-> ReadPrec DropBehaviour
-> ReadPrec [DropBehaviour]
-> Read DropBehaviour
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DropBehaviour
readsPrec :: Int -> ReadS DropBehaviour
$creadList :: ReadS [DropBehaviour]
readList :: ReadS [DropBehaviour]
$creadPrec :: ReadPrec DropBehaviour
readPrec :: ReadPrec DropBehaviour
$creadListPrec :: ReadPrec [DropBehaviour]
readListPrec :: ReadPrec [DropBehaviour]
Read,Typeable DropBehaviour
Typeable DropBehaviour =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DropBehaviour -> c DropBehaviour)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DropBehaviour)
-> (DropBehaviour -> Constr)
-> (DropBehaviour -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DropBehaviour))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DropBehaviour))
-> ((forall b. Data b => b -> b) -> DropBehaviour -> DropBehaviour)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DropBehaviour -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DropBehaviour -> r)
-> (forall u. (forall d. Data d => d -> u) -> DropBehaviour -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DropBehaviour -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DropBehaviour -> m DropBehaviour)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DropBehaviour -> m DropBehaviour)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DropBehaviour -> m DropBehaviour)
-> Data DropBehaviour
DropBehaviour -> Constr
DropBehaviour -> DataType
(forall b. Data b => b -> b) -> DropBehaviour -> DropBehaviour
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) -> DropBehaviour -> u
forall u. (forall d. Data d => d -> u) -> DropBehaviour -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DropBehaviour -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DropBehaviour -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DropBehaviour -> m DropBehaviour
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DropBehaviour -> m DropBehaviour
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DropBehaviour
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DropBehaviour -> c DropBehaviour
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DropBehaviour)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DropBehaviour)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DropBehaviour -> c DropBehaviour
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DropBehaviour -> c DropBehaviour
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DropBehaviour
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DropBehaviour
$ctoConstr :: DropBehaviour -> Constr
toConstr :: DropBehaviour -> Constr
$cdataTypeOf :: DropBehaviour -> DataType
dataTypeOf :: DropBehaviour -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DropBehaviour)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DropBehaviour)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DropBehaviour)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DropBehaviour)
$cgmapT :: (forall b. Data b => b -> b) -> DropBehaviour -> DropBehaviour
gmapT :: (forall b. Data b => b -> b) -> DropBehaviour -> DropBehaviour
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DropBehaviour -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DropBehaviour -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DropBehaviour -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DropBehaviour -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DropBehaviour -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DropBehaviour -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DropBehaviour -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DropBehaviour -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DropBehaviour -> m DropBehaviour
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DropBehaviour -> m DropBehaviour
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DropBehaviour -> m DropBehaviour
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DropBehaviour -> m DropBehaviour
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DropBehaviour -> m DropBehaviour
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DropBehaviour -> m DropBehaviour
Data,Typeable)

data IdentityRestart =
    ContinueIdentity
  | RestartIdentity
  | DefaultIdentityRestart
    deriving (IdentityRestart -> IdentityRestart -> Bool
(IdentityRestart -> IdentityRestart -> Bool)
-> (IdentityRestart -> IdentityRestart -> Bool)
-> Eq IdentityRestart
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IdentityRestart -> IdentityRestart -> Bool
== :: IdentityRestart -> IdentityRestart -> Bool
$c/= :: IdentityRestart -> IdentityRestart -> Bool
/= :: IdentityRestart -> IdentityRestart -> Bool
Eq,Int -> IdentityRestart -> ShowS
[IdentityRestart] -> ShowS
IdentityRestart -> String
(Int -> IdentityRestart -> ShowS)
-> (IdentityRestart -> String)
-> ([IdentityRestart] -> ShowS)
-> Show IdentityRestart
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IdentityRestart -> ShowS
showsPrec :: Int -> IdentityRestart -> ShowS
$cshow :: IdentityRestart -> String
show :: IdentityRestart -> String
$cshowList :: [IdentityRestart] -> ShowS
showList :: [IdentityRestart] -> ShowS
Show,ReadPrec [IdentityRestart]
ReadPrec IdentityRestart
Int -> ReadS IdentityRestart
ReadS [IdentityRestart]
(Int -> ReadS IdentityRestart)
-> ReadS [IdentityRestart]
-> ReadPrec IdentityRestart
-> ReadPrec [IdentityRestart]
-> Read IdentityRestart
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IdentityRestart
readsPrec :: Int -> ReadS IdentityRestart
$creadList :: ReadS [IdentityRestart]
readList :: ReadS [IdentityRestart]
$creadPrec :: ReadPrec IdentityRestart
readPrec :: ReadPrec IdentityRestart
$creadListPrec :: ReadPrec [IdentityRestart]
readListPrec :: ReadPrec [IdentityRestart]
Read,Typeable IdentityRestart
Typeable IdentityRestart =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> IdentityRestart -> c IdentityRestart)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c IdentityRestart)
-> (IdentityRestart -> Constr)
-> (IdentityRestart -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c IdentityRestart))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c IdentityRestart))
-> ((forall b. Data b => b -> b)
    -> IdentityRestart -> IdentityRestart)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IdentityRestart -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IdentityRestart -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> IdentityRestart -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> IdentityRestart -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> IdentityRestart -> m IdentityRestart)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IdentityRestart -> m IdentityRestart)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IdentityRestart -> m IdentityRestart)
-> Data IdentityRestart
IdentityRestart -> Constr
IdentityRestart -> DataType
(forall b. Data b => b -> b) -> IdentityRestart -> IdentityRestart
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) -> IdentityRestart -> u
forall u. (forall d. Data d => d -> u) -> IdentityRestart -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IdentityRestart -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IdentityRestart -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> IdentityRestart -> m IdentityRestart
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IdentityRestart -> m IdentityRestart
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IdentityRestart
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IdentityRestart -> c IdentityRestart
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IdentityRestart)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IdentityRestart)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IdentityRestart -> c IdentityRestart
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IdentityRestart -> c IdentityRestart
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IdentityRestart
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IdentityRestart
$ctoConstr :: IdentityRestart -> Constr
toConstr :: IdentityRestart -> Constr
$cdataTypeOf :: IdentityRestart -> DataType
dataTypeOf :: IdentityRestart -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IdentityRestart)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IdentityRestart)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IdentityRestart)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IdentityRestart)
$cgmapT :: (forall b. Data b => b -> b) -> IdentityRestart -> IdentityRestart
gmapT :: (forall b. Data b => b -> b) -> IdentityRestart -> IdentityRestart
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IdentityRestart -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IdentityRestart -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IdentityRestart -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IdentityRestart -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IdentityRestart -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> IdentityRestart -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> IdentityRestart -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> IdentityRestart -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> IdentityRestart -> m IdentityRestart
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> IdentityRestart -> m IdentityRestart
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IdentityRestart -> m IdentityRestart
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IdentityRestart -> m IdentityRestart
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IdentityRestart -> m IdentityRestart
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IdentityRestart -> m IdentityRestart
Data,Typeable)

data InsertSource =
    InsertQuery QueryExpr
  | DefaultInsertValues
    deriving (InsertSource -> InsertSource -> Bool
(InsertSource -> InsertSource -> Bool)
-> (InsertSource -> InsertSource -> Bool) -> Eq InsertSource
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InsertSource -> InsertSource -> Bool
== :: InsertSource -> InsertSource -> Bool
$c/= :: InsertSource -> InsertSource -> Bool
/= :: InsertSource -> InsertSource -> Bool
Eq,Int -> InsertSource -> ShowS
[InsertSource] -> ShowS
InsertSource -> String
(Int -> InsertSource -> ShowS)
-> (InsertSource -> String)
-> ([InsertSource] -> ShowS)
-> Show InsertSource
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InsertSource -> ShowS
showsPrec :: Int -> InsertSource -> ShowS
$cshow :: InsertSource -> String
show :: InsertSource -> String
$cshowList :: [InsertSource] -> ShowS
showList :: [InsertSource] -> ShowS
Show,ReadPrec [InsertSource]
ReadPrec InsertSource
Int -> ReadS InsertSource
ReadS [InsertSource]
(Int -> ReadS InsertSource)
-> ReadS [InsertSource]
-> ReadPrec InsertSource
-> ReadPrec [InsertSource]
-> Read InsertSource
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InsertSource
readsPrec :: Int -> ReadS InsertSource
$creadList :: ReadS [InsertSource]
readList :: ReadS [InsertSource]
$creadPrec :: ReadPrec InsertSource
readPrec :: ReadPrec InsertSource
$creadListPrec :: ReadPrec [InsertSource]
readListPrec :: ReadPrec [InsertSource]
Read,Typeable InsertSource
Typeable InsertSource =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> InsertSource -> c InsertSource)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c InsertSource)
-> (InsertSource -> Constr)
-> (InsertSource -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c InsertSource))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c InsertSource))
-> ((forall b. Data b => b -> b) -> InsertSource -> InsertSource)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InsertSource -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InsertSource -> r)
-> (forall u. (forall d. Data d => d -> u) -> InsertSource -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> InsertSource -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> InsertSource -> m InsertSource)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InsertSource -> m InsertSource)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InsertSource -> m InsertSource)
-> Data InsertSource
InsertSource -> Constr
InsertSource -> DataType
(forall b. Data b => b -> b) -> InsertSource -> InsertSource
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) -> InsertSource -> u
forall u. (forall d. Data d => d -> u) -> InsertSource -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InsertSource -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InsertSource -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InsertSource -> m InsertSource
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InsertSource -> m InsertSource
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InsertSource
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InsertSource -> c InsertSource
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InsertSource)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InsertSource)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InsertSource -> c InsertSource
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InsertSource -> c InsertSource
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InsertSource
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InsertSource
$ctoConstr :: InsertSource -> Constr
toConstr :: InsertSource -> Constr
$cdataTypeOf :: InsertSource -> DataType
dataTypeOf :: InsertSource -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InsertSource)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InsertSource)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InsertSource)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InsertSource)
$cgmapT :: (forall b. Data b => b -> b) -> InsertSource -> InsertSource
gmapT :: (forall b. Data b => b -> b) -> InsertSource -> InsertSource
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InsertSource -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InsertSource -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InsertSource -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InsertSource -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> InsertSource -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> InsertSource -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InsertSource -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InsertSource -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InsertSource -> m InsertSource
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InsertSource -> m InsertSource
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InsertSource -> m InsertSource
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InsertSource -> m InsertSource
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InsertSource -> m InsertSource
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InsertSource -> m InsertSource
Data,Typeable)

data SetClause =
    Set [Name] ScalarExpr
  | SetMultiple [[Name]] [ScalarExpr]
    deriving (SetClause -> SetClause -> Bool
(SetClause -> SetClause -> Bool)
-> (SetClause -> SetClause -> Bool) -> Eq SetClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SetClause -> SetClause -> Bool
== :: SetClause -> SetClause -> Bool
$c/= :: SetClause -> SetClause -> Bool
/= :: SetClause -> SetClause -> Bool
Eq,Int -> SetClause -> ShowS
[SetClause] -> ShowS
SetClause -> String
(Int -> SetClause -> ShowS)
-> (SetClause -> String)
-> ([SetClause] -> ShowS)
-> Show SetClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SetClause -> ShowS
showsPrec :: Int -> SetClause -> ShowS
$cshow :: SetClause -> String
show :: SetClause -> String
$cshowList :: [SetClause] -> ShowS
showList :: [SetClause] -> ShowS
Show,ReadPrec [SetClause]
ReadPrec SetClause
Int -> ReadS SetClause
ReadS [SetClause]
(Int -> ReadS SetClause)
-> ReadS [SetClause]
-> ReadPrec SetClause
-> ReadPrec [SetClause]
-> Read SetClause
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SetClause
readsPrec :: Int -> ReadS SetClause
$creadList :: ReadS [SetClause]
readList :: ReadS [SetClause]
$creadPrec :: ReadPrec SetClause
readPrec :: ReadPrec SetClause
$creadListPrec :: ReadPrec [SetClause]
readListPrec :: ReadPrec [SetClause]
Read,Typeable SetClause
Typeable SetClause =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SetClause -> c SetClause)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SetClause)
-> (SetClause -> Constr)
-> (SetClause -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SetClause))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SetClause))
-> ((forall b. Data b => b -> b) -> SetClause -> SetClause)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SetClause -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SetClause -> r)
-> (forall u. (forall d. Data d => d -> u) -> SetClause -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SetClause -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SetClause -> m SetClause)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SetClause -> m SetClause)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SetClause -> m SetClause)
-> Data SetClause
SetClause -> Constr
SetClause -> DataType
(forall b. Data b => b -> b) -> SetClause -> SetClause
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) -> SetClause -> u
forall u. (forall d. Data d => d -> u) -> SetClause -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SetClause -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SetClause -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SetClause -> m SetClause
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SetClause -> m SetClause
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetClause
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetClause -> c SetClause
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SetClause)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SetClause)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetClause -> c SetClause
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetClause -> c SetClause
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetClause
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetClause
$ctoConstr :: SetClause -> Constr
toConstr :: SetClause -> Constr
$cdataTypeOf :: SetClause -> DataType
dataTypeOf :: SetClause -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SetClause)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SetClause)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SetClause)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SetClause)
$cgmapT :: (forall b. Data b => b -> b) -> SetClause -> SetClause
gmapT :: (forall b. Data b => b -> b) -> SetClause -> SetClause
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SetClause -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SetClause -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SetClause -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SetClause -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SetClause -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SetClause -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SetClause -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SetClause -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SetClause -> m SetClause
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SetClause -> m SetClause
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SetClause -> m SetClause
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SetClause -> m SetClause
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SetClause -> m SetClause
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SetClause -> m SetClause
Data,Typeable)

data TableElement =
    TableColumnDef ColumnDef
  | TableConstraintDef (Maybe [Name]) TableConstraint
    deriving (TableElement -> TableElement -> Bool
(TableElement -> TableElement -> Bool)
-> (TableElement -> TableElement -> Bool) -> Eq TableElement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TableElement -> TableElement -> Bool
== :: TableElement -> TableElement -> Bool
$c/= :: TableElement -> TableElement -> Bool
/= :: TableElement -> TableElement -> Bool
Eq,Int -> TableElement -> ShowS
[TableElement] -> ShowS
TableElement -> String
(Int -> TableElement -> ShowS)
-> (TableElement -> String)
-> ([TableElement] -> ShowS)
-> Show TableElement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TableElement -> ShowS
showsPrec :: Int -> TableElement -> ShowS
$cshow :: TableElement -> String
show :: TableElement -> String
$cshowList :: [TableElement] -> ShowS
showList :: [TableElement] -> ShowS
Show,ReadPrec [TableElement]
ReadPrec TableElement
Int -> ReadS TableElement
ReadS [TableElement]
(Int -> ReadS TableElement)
-> ReadS [TableElement]
-> ReadPrec TableElement
-> ReadPrec [TableElement]
-> Read TableElement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TableElement
readsPrec :: Int -> ReadS TableElement
$creadList :: ReadS [TableElement]
readList :: ReadS [TableElement]
$creadPrec :: ReadPrec TableElement
readPrec :: ReadPrec TableElement
$creadListPrec :: ReadPrec [TableElement]
readListPrec :: ReadPrec [TableElement]
Read,Typeable TableElement
Typeable TableElement =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TableElement -> c TableElement)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableElement)
-> (TableElement -> Constr)
-> (TableElement -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableElement))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TableElement))
-> ((forall b. Data b => b -> b) -> TableElement -> TableElement)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableElement -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableElement -> r)
-> (forall u. (forall d. Data d => d -> u) -> TableElement -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TableElement -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TableElement -> m TableElement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableElement -> m TableElement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TableElement -> m TableElement)
-> Data TableElement
TableElement -> Constr
TableElement -> DataType
(forall b. Data b => b -> b) -> TableElement -> TableElement
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) -> TableElement -> u
forall u. (forall d. Data d => d -> u) -> TableElement -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TableElement -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TableElement -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TableElement -> m TableElement
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TableElement -> m TableElement
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TableElement
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableElement -> c TableElement
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TableElement)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TableElement)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableElement -> c TableElement
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableElement -> c TableElement
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TableElement
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TableElement
$ctoConstr :: TableElement -> Constr
toConstr :: TableElement -> Constr
$cdataTypeOf :: TableElement -> DataType
dataTypeOf :: TableElement -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TableElement)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TableElement)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TableElement)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TableElement)
$cgmapT :: (forall b. Data b => b -> b) -> TableElement -> TableElement
gmapT :: (forall b. Data b => b -> b) -> TableElement -> TableElement
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TableElement -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TableElement -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TableElement -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TableElement -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TableElement -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TableElement -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TableElement -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TableElement -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TableElement -> m TableElement
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TableElement -> m TableElement
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TableElement -> m TableElement
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TableElement -> m TableElement
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TableElement -> m TableElement
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TableElement -> m TableElement
Data,Typeable)

data ColumnDef = ColumnDef Name TypeName
       (Maybe DefaultClause)
       [ColConstraintDef]
       -- (Maybe CollateClause)
    deriving (ColumnDef -> ColumnDef -> Bool
(ColumnDef -> ColumnDef -> Bool)
-> (ColumnDef -> ColumnDef -> Bool) -> Eq ColumnDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ColumnDef -> ColumnDef -> Bool
== :: ColumnDef -> ColumnDef -> Bool
$c/= :: ColumnDef -> ColumnDef -> Bool
/= :: ColumnDef -> ColumnDef -> Bool
Eq,Int -> ColumnDef -> ShowS
[ColumnDef] -> ShowS
ColumnDef -> String
(Int -> ColumnDef -> ShowS)
-> (ColumnDef -> String)
-> ([ColumnDef] -> ShowS)
-> Show ColumnDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ColumnDef -> ShowS
showsPrec :: Int -> ColumnDef -> ShowS
$cshow :: ColumnDef -> String
show :: ColumnDef -> String
$cshowList :: [ColumnDef] -> ShowS
showList :: [ColumnDef] -> ShowS
Show,ReadPrec [ColumnDef]
ReadPrec ColumnDef
Int -> ReadS ColumnDef
ReadS [ColumnDef]
(Int -> ReadS ColumnDef)
-> ReadS [ColumnDef]
-> ReadPrec ColumnDef
-> ReadPrec [ColumnDef]
-> Read ColumnDef
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ColumnDef
readsPrec :: Int -> ReadS ColumnDef
$creadList :: ReadS [ColumnDef]
readList :: ReadS [ColumnDef]
$creadPrec :: ReadPrec ColumnDef
readPrec :: ReadPrec ColumnDef
$creadListPrec :: ReadPrec [ColumnDef]
readListPrec :: ReadPrec [ColumnDef]
Read,Typeable ColumnDef
Typeable ColumnDef =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ColumnDef -> c ColumnDef)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ColumnDef)
-> (ColumnDef -> Constr)
-> (ColumnDef -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ColumnDef))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColumnDef))
-> ((forall b. Data b => b -> b) -> ColumnDef -> ColumnDef)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ColumnDef -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ColumnDef -> r)
-> (forall u. (forall d. Data d => d -> u) -> ColumnDef -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ColumnDef -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ColumnDef -> m ColumnDef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColumnDef -> m ColumnDef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColumnDef -> m ColumnDef)
-> Data ColumnDef
ColumnDef -> Constr
ColumnDef -> DataType
(forall b. Data b => b -> b) -> ColumnDef -> ColumnDef
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) -> ColumnDef -> u
forall u. (forall d. Data d => d -> u) -> ColumnDef -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnDef -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnDef -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ColumnDef -> m ColumnDef
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ColumnDef -> m ColumnDef
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColumnDef
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColumnDef -> c ColumnDef
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ColumnDef)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColumnDef)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColumnDef -> c ColumnDef
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColumnDef -> c ColumnDef
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColumnDef
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColumnDef
$ctoConstr :: ColumnDef -> Constr
toConstr :: ColumnDef -> Constr
$cdataTypeOf :: ColumnDef -> DataType
dataTypeOf :: ColumnDef -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ColumnDef)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ColumnDef)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColumnDef)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColumnDef)
$cgmapT :: (forall b. Data b => b -> b) -> ColumnDef -> ColumnDef
gmapT :: (forall b. Data b => b -> b) -> ColumnDef -> ColumnDef
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnDef -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnDef -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnDef -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnDef -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ColumnDef -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ColumnDef -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ColumnDef -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ColumnDef -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ColumnDef -> m ColumnDef
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ColumnDef -> m ColumnDef
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ColumnDef -> m ColumnDef
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ColumnDef -> m ColumnDef
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ColumnDef -> m ColumnDef
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ColumnDef -> m ColumnDef
Data,Typeable)

data ColConstraintDef =
    ColConstraintDef (Maybe [Name]) ColConstraint
      -- (Maybe [ConstraintCharacteristics])
    deriving (ColConstraintDef -> ColConstraintDef -> Bool
(ColConstraintDef -> ColConstraintDef -> Bool)
-> (ColConstraintDef -> ColConstraintDef -> Bool)
-> Eq ColConstraintDef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ColConstraintDef -> ColConstraintDef -> Bool
== :: ColConstraintDef -> ColConstraintDef -> Bool
$c/= :: ColConstraintDef -> ColConstraintDef -> Bool
/= :: ColConstraintDef -> ColConstraintDef -> Bool
Eq,Int -> ColConstraintDef -> ShowS
[ColConstraintDef] -> ShowS
ColConstraintDef -> String
(Int -> ColConstraintDef -> ShowS)
-> (ColConstraintDef -> String)
-> ([ColConstraintDef] -> ShowS)
-> Show ColConstraintDef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ColConstraintDef -> ShowS
showsPrec :: Int -> ColConstraintDef -> ShowS
$cshow :: ColConstraintDef -> String
show :: ColConstraintDef -> String
$cshowList :: [ColConstraintDef] -> ShowS
showList :: [ColConstraintDef] -> ShowS
Show,ReadPrec [ColConstraintDef]
ReadPrec ColConstraintDef
Int -> ReadS ColConstraintDef
ReadS [ColConstraintDef]
(Int -> ReadS ColConstraintDef)
-> ReadS [ColConstraintDef]
-> ReadPrec ColConstraintDef
-> ReadPrec [ColConstraintDef]
-> Read ColConstraintDef
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ColConstraintDef
readsPrec :: Int -> ReadS ColConstraintDef
$creadList :: ReadS [ColConstraintDef]
readList :: ReadS [ColConstraintDef]
$creadPrec :: ReadPrec ColConstraintDef
readPrec :: ReadPrec ColConstraintDef
$creadListPrec :: ReadPrec [ColConstraintDef]
readListPrec :: ReadPrec [ColConstraintDef]
Read,Typeable ColConstraintDef
Typeable ColConstraintDef =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ColConstraintDef -> c ColConstraintDef)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ColConstraintDef)
-> (ColConstraintDef -> Constr)
-> (ColConstraintDef -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ColConstraintDef))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ColConstraintDef))
-> ((forall b. Data b => b -> b)
    -> ColConstraintDef -> ColConstraintDef)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ColConstraintDef -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ColConstraintDef -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ColConstraintDef -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ColConstraintDef -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ColConstraintDef -> m ColConstraintDef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ColConstraintDef -> m ColConstraintDef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ColConstraintDef -> m ColConstraintDef)
-> Data ColConstraintDef
ColConstraintDef -> Constr
ColConstraintDef -> DataType
(forall b. Data b => b -> b)
-> ColConstraintDef -> ColConstraintDef
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) -> ColConstraintDef -> u
forall u. (forall d. Data d => d -> u) -> ColConstraintDef -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColConstraintDef -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ColConstraintDef -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ColConstraintDef -> m ColConstraintDef
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ColConstraintDef -> m ColConstraintDef
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColConstraintDef
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColConstraintDef -> c ColConstraintDef
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ColConstraintDef)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ColConstraintDef)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColConstraintDef -> c ColConstraintDef
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColConstraintDef -> c ColConstraintDef
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColConstraintDef
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColConstraintDef
$ctoConstr :: ColConstraintDef -> Constr
toConstr :: ColConstraintDef -> Constr
$cdataTypeOf :: ColConstraintDef -> DataType
dataTypeOf :: ColConstraintDef -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ColConstraintDef)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ColConstraintDef)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ColConstraintDef)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ColConstraintDef)
$cgmapT :: (forall b. Data b => b -> b)
-> ColConstraintDef -> ColConstraintDef
gmapT :: (forall b. Data b => b -> b)
-> ColConstraintDef -> ColConstraintDef
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColConstraintDef -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColConstraintDef -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ColConstraintDef -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ColConstraintDef -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ColConstraintDef -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ColConstraintDef -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ColConstraintDef -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ColConstraintDef -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ColConstraintDef -> m ColConstraintDef
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ColConstraintDef -> m ColConstraintDef
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ColConstraintDef -> m ColConstraintDef
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ColConstraintDef -> m ColConstraintDef
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ColConstraintDef -> m ColConstraintDef
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ColConstraintDef -> m ColConstraintDef
Data,Typeable)

type AutoincrementClause = Bool

data ColConstraint =
    ColNullableConstraint
  | ColNotNullConstraint
  | ColUniqueConstraint
  | ColPrimaryKeyConstraint AutoincrementClause
  | ColReferencesConstraint [Name] (Maybe Name)
       ReferenceMatch
       ReferentialAction
       ReferentialAction
  | ColCheckConstraint ScalarExpr
    deriving (ColConstraint -> ColConstraint -> Bool
(ColConstraint -> ColConstraint -> Bool)
-> (ColConstraint -> ColConstraint -> Bool) -> Eq ColConstraint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ColConstraint -> ColConstraint -> Bool
== :: ColConstraint -> ColConstraint -> Bool
$c/= :: ColConstraint -> ColConstraint -> Bool
/= :: ColConstraint -> ColConstraint -> Bool
Eq,Int -> ColConstraint -> ShowS
[ColConstraint] -> ShowS
ColConstraint -> String
(Int -> ColConstraint -> ShowS)
-> (ColConstraint -> String)
-> ([ColConstraint] -> ShowS)
-> Show ColConstraint
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ColConstraint -> ShowS
showsPrec :: Int -> ColConstraint -> ShowS
$cshow :: ColConstraint -> String
show :: ColConstraint -> String
$cshowList :: [ColConstraint] -> ShowS
showList :: [ColConstraint] -> ShowS
Show,ReadPrec [ColConstraint]
ReadPrec ColConstraint
Int -> ReadS ColConstraint
ReadS [ColConstraint]
(Int -> ReadS ColConstraint)
-> ReadS [ColConstraint]
-> ReadPrec ColConstraint
-> ReadPrec [ColConstraint]
-> Read ColConstraint
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ColConstraint
readsPrec :: Int -> ReadS ColConstraint
$creadList :: ReadS [ColConstraint]
readList :: ReadS [ColConstraint]
$creadPrec :: ReadPrec ColConstraint
readPrec :: ReadPrec ColConstraint
$creadListPrec :: ReadPrec [ColConstraint]
readListPrec :: ReadPrec [ColConstraint]
Read,Typeable ColConstraint
Typeable ColConstraint =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ColConstraint -> c ColConstraint)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ColConstraint)
-> (ColConstraint -> Constr)
-> (ColConstraint -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ColConstraint))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ColConstraint))
-> ((forall b. Data b => b -> b) -> ColConstraint -> ColConstraint)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ColConstraint -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ColConstraint -> r)
-> (forall u. (forall d. Data d => d -> u) -> ColConstraint -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ColConstraint -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ColConstraint -> m ColConstraint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColConstraint -> m ColConstraint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ColConstraint -> m ColConstraint)
-> Data ColConstraint
ColConstraint -> Constr
ColConstraint -> DataType
(forall b. Data b => b -> b) -> ColConstraint -> ColConstraint
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) -> ColConstraint -> u
forall u. (forall d. Data d => d -> u) -> ColConstraint -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColConstraint -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ColConstraint -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ColConstraint -> m ColConstraint
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ColConstraint -> m ColConstraint
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColConstraint
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColConstraint -> c ColConstraint
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ColConstraint)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ColConstraint)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColConstraint -> c ColConstraint
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColConstraint -> c ColConstraint
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColConstraint
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColConstraint
$ctoConstr :: ColConstraint -> Constr
toConstr :: ColConstraint -> Constr
$cdataTypeOf :: ColConstraint -> DataType
dataTypeOf :: ColConstraint -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ColConstraint)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ColConstraint)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ColConstraint)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ColConstraint)
$cgmapT :: (forall b. Data b => b -> b) -> ColConstraint -> ColConstraint
gmapT :: (forall b. Data b => b -> b) -> ColConstraint -> ColConstraint
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColConstraint -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColConstraint -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ColConstraint -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ColConstraint -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ColConstraint -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ColConstraint -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ColConstraint -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ColConstraint -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ColConstraint -> m ColConstraint
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ColConstraint -> m ColConstraint
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ColConstraint -> m ColConstraint
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ColConstraint -> m ColConstraint
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ColConstraint -> m ColConstraint
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ColConstraint -> m ColConstraint
Data,Typeable)

data TableConstraint =
    TableUniqueConstraint [Name]
  | TablePrimaryKeyConstraint [Name]
  | TableReferencesConstraint [Name] [Name] (Maybe [Name])
       ReferenceMatch
       ReferentialAction
       ReferentialAction
  | TableCheckConstraint ScalarExpr
    deriving (TableConstraint -> TableConstraint -> Bool
(TableConstraint -> TableConstraint -> Bool)
-> (TableConstraint -> TableConstraint -> Bool)
-> Eq TableConstraint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TableConstraint -> TableConstraint -> Bool
== :: TableConstraint -> TableConstraint -> Bool
$c/= :: TableConstraint -> TableConstraint -> Bool
/= :: TableConstraint -> TableConstraint -> Bool
Eq,Int -> TableConstraint -> ShowS
[TableConstraint] -> ShowS
TableConstraint -> String
(Int -> TableConstraint -> ShowS)
-> (TableConstraint -> String)
-> ([TableConstraint] -> ShowS)
-> Show TableConstraint
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TableConstraint -> ShowS
showsPrec :: Int -> TableConstraint -> ShowS
$cshow :: TableConstraint -> String
show :: TableConstraint -> String
$cshowList :: [TableConstraint] -> ShowS
showList :: [TableConstraint] -> ShowS
Show,ReadPrec [TableConstraint]
ReadPrec TableConstraint
Int -> ReadS TableConstraint
ReadS [TableConstraint]
(Int -> ReadS TableConstraint)
-> ReadS [TableConstraint]
-> ReadPrec TableConstraint
-> ReadPrec [TableConstraint]
-> Read TableConstraint
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TableConstraint
readsPrec :: Int -> ReadS TableConstraint
$creadList :: ReadS [TableConstraint]
readList :: ReadS [TableConstraint]
$creadPrec :: ReadPrec TableConstraint
readPrec :: ReadPrec TableConstraint
$creadListPrec :: ReadPrec [TableConstraint]
readListPrec :: ReadPrec [TableConstraint]
Read,Typeable TableConstraint
Typeable TableConstraint =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TableConstraint -> c TableConstraint)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TableConstraint)
-> (TableConstraint -> Constr)
-> (TableConstraint -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TableConstraint))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TableConstraint))
-> ((forall b. Data b => b -> b)
    -> TableConstraint -> TableConstraint)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TableConstraint -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TableConstraint -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TableConstraint -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TableConstraint -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TableConstraint -> m TableConstraint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TableConstraint -> m TableConstraint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TableConstraint -> m TableConstraint)
-> Data TableConstraint
TableConstraint -> Constr
TableConstraint -> DataType
(forall b. Data b => b -> b) -> TableConstraint -> TableConstraint
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) -> TableConstraint -> u
forall u. (forall d. Data d => d -> u) -> TableConstraint -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TableConstraint -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TableConstraint -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TableConstraint -> m TableConstraint
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TableConstraint -> m TableConstraint
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TableConstraint
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableConstraint -> c TableConstraint
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TableConstraint)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TableConstraint)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableConstraint -> c TableConstraint
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableConstraint -> c TableConstraint
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TableConstraint
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TableConstraint
$ctoConstr :: TableConstraint -> Constr
toConstr :: TableConstraint -> Constr
$cdataTypeOf :: TableConstraint -> DataType
dataTypeOf :: TableConstraint -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TableConstraint)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TableConstraint)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TableConstraint)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TableConstraint)
$cgmapT :: (forall b. Data b => b -> b) -> TableConstraint -> TableConstraint
gmapT :: (forall b. Data b => b -> b) -> TableConstraint -> TableConstraint
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TableConstraint -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TableConstraint -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TableConstraint -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TableConstraint -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TableConstraint -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TableConstraint -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TableConstraint -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TableConstraint -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TableConstraint -> m TableConstraint
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TableConstraint -> m TableConstraint
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TableConstraint -> m TableConstraint
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TableConstraint -> m TableConstraint
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TableConstraint -> m TableConstraint
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TableConstraint -> m TableConstraint
Data,Typeable)


data ReferenceMatch =
    DefaultReferenceMatch
  | MatchFull
  | MatchPartial
  | MatchSimple
    deriving (ReferenceMatch -> ReferenceMatch -> Bool
(ReferenceMatch -> ReferenceMatch -> Bool)
-> (ReferenceMatch -> ReferenceMatch -> Bool) -> Eq ReferenceMatch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ReferenceMatch -> ReferenceMatch -> Bool
== :: ReferenceMatch -> ReferenceMatch -> Bool
$c/= :: ReferenceMatch -> ReferenceMatch -> Bool
/= :: ReferenceMatch -> ReferenceMatch -> Bool
Eq,Int -> ReferenceMatch -> ShowS
[ReferenceMatch] -> ShowS
ReferenceMatch -> String
(Int -> ReferenceMatch -> ShowS)
-> (ReferenceMatch -> String)
-> ([ReferenceMatch] -> ShowS)
-> Show ReferenceMatch
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ReferenceMatch -> ShowS
showsPrec :: Int -> ReferenceMatch -> ShowS
$cshow :: ReferenceMatch -> String
show :: ReferenceMatch -> String
$cshowList :: [ReferenceMatch] -> ShowS
showList :: [ReferenceMatch] -> ShowS
Show,ReadPrec [ReferenceMatch]
ReadPrec ReferenceMatch
Int -> ReadS ReferenceMatch
ReadS [ReferenceMatch]
(Int -> ReadS ReferenceMatch)
-> ReadS [ReferenceMatch]
-> ReadPrec ReferenceMatch
-> ReadPrec [ReferenceMatch]
-> Read ReferenceMatch
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ReferenceMatch
readsPrec :: Int -> ReadS ReferenceMatch
$creadList :: ReadS [ReferenceMatch]
readList :: ReadS [ReferenceMatch]
$creadPrec :: ReadPrec ReferenceMatch
readPrec :: ReadPrec ReferenceMatch
$creadListPrec :: ReadPrec [ReferenceMatch]
readListPrec :: ReadPrec [ReferenceMatch]
Read,Typeable ReferenceMatch
Typeable ReferenceMatch =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ReferenceMatch -> c ReferenceMatch)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ReferenceMatch)
-> (ReferenceMatch -> Constr)
-> (ReferenceMatch -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ReferenceMatch))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ReferenceMatch))
-> ((forall b. Data b => b -> b)
    -> ReferenceMatch -> ReferenceMatch)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ReferenceMatch -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ReferenceMatch -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ReferenceMatch -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ReferenceMatch -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ReferenceMatch -> m ReferenceMatch)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ReferenceMatch -> m ReferenceMatch)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ReferenceMatch -> m ReferenceMatch)
-> Data ReferenceMatch
ReferenceMatch -> Constr
ReferenceMatch -> DataType
(forall b. Data b => b -> b) -> ReferenceMatch -> ReferenceMatch
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) -> ReferenceMatch -> u
forall u. (forall d. Data d => d -> u) -> ReferenceMatch -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ReferenceMatch -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ReferenceMatch -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ReferenceMatch -> m ReferenceMatch
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ReferenceMatch -> m ReferenceMatch
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ReferenceMatch
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ReferenceMatch -> c ReferenceMatch
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ReferenceMatch)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ReferenceMatch)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ReferenceMatch -> c ReferenceMatch
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ReferenceMatch -> c ReferenceMatch
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ReferenceMatch
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ReferenceMatch
$ctoConstr :: ReferenceMatch -> Constr
toConstr :: ReferenceMatch -> Constr
$cdataTypeOf :: ReferenceMatch -> DataType
dataTypeOf :: ReferenceMatch -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ReferenceMatch)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ReferenceMatch)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ReferenceMatch)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ReferenceMatch)
$cgmapT :: (forall b. Data b => b -> b) -> ReferenceMatch -> ReferenceMatch
gmapT :: (forall b. Data b => b -> b) -> ReferenceMatch -> ReferenceMatch
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ReferenceMatch -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ReferenceMatch -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ReferenceMatch -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ReferenceMatch -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ReferenceMatch -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ReferenceMatch -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ReferenceMatch -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ReferenceMatch -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ReferenceMatch -> m ReferenceMatch
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ReferenceMatch -> m ReferenceMatch
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ReferenceMatch -> m ReferenceMatch
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ReferenceMatch -> m ReferenceMatch
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ReferenceMatch -> m ReferenceMatch
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ReferenceMatch -> m ReferenceMatch
Data,Typeable)

data ReferentialAction =
    DefaultReferentialAction
  | RefCascade
  | RefSetNull
  | RefSetDefault
  | RefRestrict
  | RefNoAction
    deriving (ReferentialAction -> ReferentialAction -> Bool
(ReferentialAction -> ReferentialAction -> Bool)
-> (ReferentialAction -> ReferentialAction -> Bool)
-> Eq ReferentialAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ReferentialAction -> ReferentialAction -> Bool
== :: ReferentialAction -> ReferentialAction -> Bool
$c/= :: ReferentialAction -> ReferentialAction -> Bool
/= :: ReferentialAction -> ReferentialAction -> Bool
Eq,Int -> ReferentialAction -> ShowS
[ReferentialAction] -> ShowS
ReferentialAction -> String
(Int -> ReferentialAction -> ShowS)
-> (ReferentialAction -> String)
-> ([ReferentialAction] -> ShowS)
-> Show ReferentialAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ReferentialAction -> ShowS
showsPrec :: Int -> ReferentialAction -> ShowS
$cshow :: ReferentialAction -> String
show :: ReferentialAction -> String
$cshowList :: [ReferentialAction] -> ShowS
showList :: [ReferentialAction] -> ShowS
Show,ReadPrec [ReferentialAction]
ReadPrec ReferentialAction
Int -> ReadS ReferentialAction
ReadS [ReferentialAction]
(Int -> ReadS ReferentialAction)
-> ReadS [ReferentialAction]
-> ReadPrec ReferentialAction
-> ReadPrec [ReferentialAction]
-> Read ReferentialAction
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ReferentialAction
readsPrec :: Int -> ReadS ReferentialAction
$creadList :: ReadS [ReferentialAction]
readList :: ReadS [ReferentialAction]
$creadPrec :: ReadPrec ReferentialAction
readPrec :: ReadPrec ReferentialAction
$creadListPrec :: ReadPrec [ReferentialAction]
readListPrec :: ReadPrec [ReferentialAction]
Read,Typeable ReferentialAction
Typeable ReferentialAction =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> ReferentialAction
 -> c ReferentialAction)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ReferentialAction)
-> (ReferentialAction -> Constr)
-> (ReferentialAction -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ReferentialAction))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ReferentialAction))
-> ((forall b. Data b => b -> b)
    -> ReferentialAction -> ReferentialAction)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ReferentialAction -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ReferentialAction -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ReferentialAction -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ReferentialAction -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ReferentialAction -> m ReferentialAction)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ReferentialAction -> m ReferentialAction)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ReferentialAction -> m ReferentialAction)
-> Data ReferentialAction
ReferentialAction -> Constr
ReferentialAction -> DataType
(forall b. Data b => b -> b)
-> ReferentialAction -> ReferentialAction
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) -> ReferentialAction -> u
forall u. (forall d. Data d => d -> u) -> ReferentialAction -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ReferentialAction -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ReferentialAction -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ReferentialAction -> m ReferentialAction
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ReferentialAction -> m ReferentialAction
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ReferentialAction
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ReferentialAction -> c ReferentialAction
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ReferentialAction)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ReferentialAction)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ReferentialAction -> c ReferentialAction
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ReferentialAction -> c ReferentialAction
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ReferentialAction
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ReferentialAction
$ctoConstr :: ReferentialAction -> Constr
toConstr :: ReferentialAction -> Constr
$cdataTypeOf :: ReferentialAction -> DataType
dataTypeOf :: ReferentialAction -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ReferentialAction)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ReferentialAction)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ReferentialAction)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ReferentialAction)
$cgmapT :: (forall b. Data b => b -> b)
-> ReferentialAction -> ReferentialAction
gmapT :: (forall b. Data b => b -> b)
-> ReferentialAction -> ReferentialAction
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ReferentialAction -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ReferentialAction -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ReferentialAction -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ReferentialAction -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ReferentialAction -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ReferentialAction -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ReferentialAction -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ReferentialAction -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ReferentialAction -> m ReferentialAction
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ReferentialAction -> m ReferentialAction
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ReferentialAction -> m ReferentialAction
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ReferentialAction -> m ReferentialAction
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ReferentialAction -> m ReferentialAction
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ReferentialAction -> m ReferentialAction
Data,Typeable)

data AlterTableAction =
    AddColumnDef ColumnDef
  | AlterColumnSetDefault Name ScalarExpr
  | AlterColumnDropDefault Name
  | AlterColumnSetNotNull Name
  | AlterColumnDropNotNull Name
  | AlterColumnSetDataType Name TypeName
  {-  | AlterColumnAlterIdentity
  | AlterColumnDropIdentity
  | AlterColumnDropColumnGeneration-}
  | DropColumn Name DropBehaviour
  | AddTableConstraintDef (Maybe [Name]) TableConstraint
  --  | AlterTableConstraintDef
  | DropTableConstraintDef [Name] DropBehaviour
    deriving (AlterTableAction -> AlterTableAction -> Bool
(AlterTableAction -> AlterTableAction -> Bool)
-> (AlterTableAction -> AlterTableAction -> Bool)
-> Eq AlterTableAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AlterTableAction -> AlterTableAction -> Bool
== :: AlterTableAction -> AlterTableAction -> Bool
$c/= :: AlterTableAction -> AlterTableAction -> Bool
/= :: AlterTableAction -> AlterTableAction -> Bool
Eq,Int -> AlterTableAction -> ShowS
[AlterTableAction] -> ShowS
AlterTableAction -> String
(Int -> AlterTableAction -> ShowS)
-> (AlterTableAction -> String)
-> ([AlterTableAction] -> ShowS)
-> Show AlterTableAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AlterTableAction -> ShowS
showsPrec :: Int -> AlterTableAction -> ShowS
$cshow :: AlterTableAction -> String
show :: AlterTableAction -> String
$cshowList :: [AlterTableAction] -> ShowS
showList :: [AlterTableAction] -> ShowS
Show,ReadPrec [AlterTableAction]
ReadPrec AlterTableAction
Int -> ReadS AlterTableAction
ReadS [AlterTableAction]
(Int -> ReadS AlterTableAction)
-> ReadS [AlterTableAction]
-> ReadPrec AlterTableAction
-> ReadPrec [AlterTableAction]
-> Read AlterTableAction
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AlterTableAction
readsPrec :: Int -> ReadS AlterTableAction
$creadList :: ReadS [AlterTableAction]
readList :: ReadS [AlterTableAction]
$creadPrec :: ReadPrec AlterTableAction
readPrec :: ReadPrec AlterTableAction
$creadListPrec :: ReadPrec [AlterTableAction]
readListPrec :: ReadPrec [AlterTableAction]
Read,Typeable AlterTableAction
Typeable AlterTableAction =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> AlterTableAction -> c AlterTableAction)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AlterTableAction)
-> (AlterTableAction -> Constr)
-> (AlterTableAction -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AlterTableAction))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AlterTableAction))
-> ((forall b. Data b => b -> b)
    -> AlterTableAction -> AlterTableAction)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AlterTableAction -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AlterTableAction -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> AlterTableAction -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> AlterTableAction -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AlterTableAction -> m AlterTableAction)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AlterTableAction -> m AlterTableAction)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AlterTableAction -> m AlterTableAction)
-> Data AlterTableAction
AlterTableAction -> Constr
AlterTableAction -> DataType
(forall b. Data b => b -> b)
-> AlterTableAction -> AlterTableAction
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) -> AlterTableAction -> u
forall u. (forall d. Data d => d -> u) -> AlterTableAction -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlterTableAction -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AlterTableAction -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AlterTableAction -> m AlterTableAction
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AlterTableAction -> m AlterTableAction
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlterTableAction
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlterTableAction -> c AlterTableAction
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlterTableAction)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AlterTableAction)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlterTableAction -> c AlterTableAction
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlterTableAction -> c AlterTableAction
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlterTableAction
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlterTableAction
$ctoConstr :: AlterTableAction -> Constr
toConstr :: AlterTableAction -> Constr
$cdataTypeOf :: AlterTableAction -> DataType
dataTypeOf :: AlterTableAction -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlterTableAction)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlterTableAction)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AlterTableAction)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AlterTableAction)
$cgmapT :: (forall b. Data b => b -> b)
-> AlterTableAction -> AlterTableAction
gmapT :: (forall b. Data b => b -> b)
-> AlterTableAction -> AlterTableAction
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlterTableAction -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlterTableAction -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AlterTableAction -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AlterTableAction -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AlterTableAction -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AlterTableAction -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> AlterTableAction -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> AlterTableAction -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AlterTableAction -> m AlterTableAction
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AlterTableAction -> m AlterTableAction
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AlterTableAction -> m AlterTableAction
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AlterTableAction -> m AlterTableAction
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AlterTableAction -> m AlterTableAction
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AlterTableAction -> m AlterTableAction
Data,Typeable)

{-data ConstraintCharacteristics =
    ConstraintCharacteristics
        ConstraintCheckTime
        Deferrable
        ConstraintEnforcement
    deriving (Eq,Show,Read,Data,Typeable)

data ConstraintCheckTime =
    DefaultConstraintCheckTime
  | InitiallyDeferred
  | InitiallyImmeditate
    deriving (Eq,Show,Read,Data,Typeable)

data Deferrable =
    DefaultDefferable
  | Deferrable
  | NotDeferrable
    deriving (Eq,Show,Read,Data,Typeable)

data ConstraintEnforcement =
    DefaultConstraintEnforcement
  | Enforced
  | NotEnforced
    deriving (Eq,Show,Read,Data,Typeable) -}

{-data TableConstraintDef
    deriving (Eq,Show,Read,Data,Typeable) -}

data DefaultClause =
     DefaultClause ScalarExpr
   | IdentityColumnSpec IdentityWhen [SequenceGeneratorOption]
   | GenerationClause ScalarExpr
    deriving (DefaultClause -> DefaultClause -> Bool
(DefaultClause -> DefaultClause -> Bool)
-> (DefaultClause -> DefaultClause -> Bool) -> Eq DefaultClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DefaultClause -> DefaultClause -> Bool
== :: DefaultClause -> DefaultClause -> Bool
$c/= :: DefaultClause -> DefaultClause -> Bool
/= :: DefaultClause -> DefaultClause -> Bool
Eq,Int -> DefaultClause -> ShowS
[DefaultClause] -> ShowS
DefaultClause -> String
(Int -> DefaultClause -> ShowS)
-> (DefaultClause -> String)
-> ([DefaultClause] -> ShowS)
-> Show DefaultClause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DefaultClause -> ShowS
showsPrec :: Int -> DefaultClause -> ShowS
$cshow :: DefaultClause -> String
show :: DefaultClause -> String
$cshowList :: [DefaultClause] -> ShowS
showList :: [DefaultClause] -> ShowS
Show,ReadPrec [DefaultClause]
ReadPrec DefaultClause
Int -> ReadS DefaultClause
ReadS [DefaultClause]
(Int -> ReadS DefaultClause)
-> ReadS [DefaultClause]
-> ReadPrec DefaultClause
-> ReadPrec [DefaultClause]
-> Read DefaultClause
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DefaultClause
readsPrec :: Int -> ReadS DefaultClause
$creadList :: ReadS [DefaultClause]
readList :: ReadS [DefaultClause]
$creadPrec :: ReadPrec DefaultClause
readPrec :: ReadPrec DefaultClause
$creadListPrec :: ReadPrec [DefaultClause]
readListPrec :: ReadPrec [DefaultClause]
Read,Typeable DefaultClause
Typeable DefaultClause =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DefaultClause -> c DefaultClause)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DefaultClause)
-> (DefaultClause -> Constr)
-> (DefaultClause -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DefaultClause))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DefaultClause))
-> ((forall b. Data b => b -> b) -> DefaultClause -> DefaultClause)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DefaultClause -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DefaultClause -> r)
-> (forall u. (forall d. Data d => d -> u) -> DefaultClause -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DefaultClause -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DefaultClause -> m DefaultClause)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DefaultClause -> m DefaultClause)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DefaultClause -> m DefaultClause)
-> Data DefaultClause
DefaultClause -> Constr
DefaultClause -> DataType
(forall b. Data b => b -> b) -> DefaultClause -> DefaultClause
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) -> DefaultClause -> u
forall u. (forall d. Data d => d -> u) -> DefaultClause -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DefaultClause -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DefaultClause -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DefaultClause -> m DefaultClause
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DefaultClause -> m DefaultClause
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DefaultClause
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefaultClause -> c DefaultClause
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DefaultClause)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DefaultClause)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefaultClause -> c DefaultClause
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefaultClause -> c DefaultClause
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DefaultClause
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DefaultClause
$ctoConstr :: DefaultClause -> Constr
toConstr :: DefaultClause -> Constr
$cdataTypeOf :: DefaultClause -> DataType
dataTypeOf :: DefaultClause -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DefaultClause)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DefaultClause)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DefaultClause)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DefaultClause)
$cgmapT :: (forall b. Data b => b -> b) -> DefaultClause -> DefaultClause
gmapT :: (forall b. Data b => b -> b) -> DefaultClause -> DefaultClause
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DefaultClause -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DefaultClause -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DefaultClause -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DefaultClause -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DefaultClause -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DefaultClause -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DefaultClause -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DefaultClause -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DefaultClause -> m DefaultClause
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DefaultClause -> m DefaultClause
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DefaultClause -> m DefaultClause
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DefaultClause -> m DefaultClause
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DefaultClause -> m DefaultClause
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DefaultClause -> m DefaultClause
Data,Typeable)

data IdentityWhen =
    GeneratedAlways
  | GeneratedByDefault
    deriving (IdentityWhen -> IdentityWhen -> Bool
(IdentityWhen -> IdentityWhen -> Bool)
-> (IdentityWhen -> IdentityWhen -> Bool) -> Eq IdentityWhen
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IdentityWhen -> IdentityWhen -> Bool
== :: IdentityWhen -> IdentityWhen -> Bool
$c/= :: IdentityWhen -> IdentityWhen -> Bool
/= :: IdentityWhen -> IdentityWhen -> Bool
Eq,Int -> IdentityWhen -> ShowS
[IdentityWhen] -> ShowS
IdentityWhen -> String
(Int -> IdentityWhen -> ShowS)
-> (IdentityWhen -> String)
-> ([IdentityWhen] -> ShowS)
-> Show IdentityWhen
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IdentityWhen -> ShowS
showsPrec :: Int -> IdentityWhen -> ShowS
$cshow :: IdentityWhen -> String
show :: IdentityWhen -> String
$cshowList :: [IdentityWhen] -> ShowS
showList :: [IdentityWhen] -> ShowS
Show,ReadPrec [IdentityWhen]
ReadPrec IdentityWhen
Int -> ReadS IdentityWhen
ReadS [IdentityWhen]
(Int -> ReadS IdentityWhen)
-> ReadS [IdentityWhen]
-> ReadPrec IdentityWhen
-> ReadPrec [IdentityWhen]
-> Read IdentityWhen
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IdentityWhen
readsPrec :: Int -> ReadS IdentityWhen
$creadList :: ReadS [IdentityWhen]
readList :: ReadS [IdentityWhen]
$creadPrec :: ReadPrec IdentityWhen
readPrec :: ReadPrec IdentityWhen
$creadListPrec :: ReadPrec [IdentityWhen]
readListPrec :: ReadPrec [IdentityWhen]
Read,Typeable IdentityWhen
Typeable IdentityWhen =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> IdentityWhen -> c IdentityWhen)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c IdentityWhen)
-> (IdentityWhen -> Constr)
-> (IdentityWhen -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c IdentityWhen))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c IdentityWhen))
-> ((forall b. Data b => b -> b) -> IdentityWhen -> IdentityWhen)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IdentityWhen -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IdentityWhen -> r)
-> (forall u. (forall d. Data d => d -> u) -> IdentityWhen -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> IdentityWhen -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> IdentityWhen -> m IdentityWhen)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IdentityWhen -> m IdentityWhen)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IdentityWhen -> m IdentityWhen)
-> Data IdentityWhen
IdentityWhen -> Constr
IdentityWhen -> DataType
(forall b. Data b => b -> b) -> IdentityWhen -> IdentityWhen
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) -> IdentityWhen -> u
forall u. (forall d. Data d => d -> u) -> IdentityWhen -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IdentityWhen -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IdentityWhen -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IdentityWhen -> m IdentityWhen
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IdentityWhen -> m IdentityWhen
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IdentityWhen
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IdentityWhen -> c IdentityWhen
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IdentityWhen)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IdentityWhen)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IdentityWhen -> c IdentityWhen
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IdentityWhen -> c IdentityWhen
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IdentityWhen
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IdentityWhen
$ctoConstr :: IdentityWhen -> Constr
toConstr :: IdentityWhen -> Constr
$cdataTypeOf :: IdentityWhen -> DataType
dataTypeOf :: IdentityWhen -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IdentityWhen)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IdentityWhen)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IdentityWhen)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IdentityWhen)
$cgmapT :: (forall b. Data b => b -> b) -> IdentityWhen -> IdentityWhen
gmapT :: (forall b. Data b => b -> b) -> IdentityWhen -> IdentityWhen
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IdentityWhen -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IdentityWhen -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IdentityWhen -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IdentityWhen -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IdentityWhen -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> IdentityWhen -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IdentityWhen -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IdentityWhen -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IdentityWhen -> m IdentityWhen
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IdentityWhen -> m IdentityWhen
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IdentityWhen -> m IdentityWhen
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IdentityWhen -> m IdentityWhen
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IdentityWhen -> m IdentityWhen
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IdentityWhen -> m IdentityWhen
Data,Typeable)

data SequenceGeneratorOption =
    SGODataType TypeName
  | SGOStartWith Integer
  | SGORestart (Maybe Integer)
  | SGOIncrementBy Integer
  | SGOMaxValue Integer
  | SGONoMaxValue
  | SGOMinValue Integer
  | SGONoMinValue
  | SGOCycle
  | SGONoCycle
    deriving (SequenceGeneratorOption -> SequenceGeneratorOption -> Bool
(SequenceGeneratorOption -> SequenceGeneratorOption -> Bool)
-> (SequenceGeneratorOption -> SequenceGeneratorOption -> Bool)
-> Eq SequenceGeneratorOption
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SequenceGeneratorOption -> SequenceGeneratorOption -> Bool
== :: SequenceGeneratorOption -> SequenceGeneratorOption -> Bool
$c/= :: SequenceGeneratorOption -> SequenceGeneratorOption -> Bool
/= :: SequenceGeneratorOption -> SequenceGeneratorOption -> Bool
Eq,Int -> SequenceGeneratorOption -> ShowS
[SequenceGeneratorOption] -> ShowS
SequenceGeneratorOption -> String
(Int -> SequenceGeneratorOption -> ShowS)
-> (SequenceGeneratorOption -> String)
-> ([SequenceGeneratorOption] -> ShowS)
-> Show SequenceGeneratorOption
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SequenceGeneratorOption -> ShowS
showsPrec :: Int -> SequenceGeneratorOption -> ShowS
$cshow :: SequenceGeneratorOption -> String
show :: SequenceGeneratorOption -> String
$cshowList :: [SequenceGeneratorOption] -> ShowS
showList :: [SequenceGeneratorOption] -> ShowS
Show,ReadPrec [SequenceGeneratorOption]
ReadPrec SequenceGeneratorOption
Int -> ReadS SequenceGeneratorOption
ReadS [SequenceGeneratorOption]
(Int -> ReadS SequenceGeneratorOption)
-> ReadS [SequenceGeneratorOption]
-> ReadPrec SequenceGeneratorOption
-> ReadPrec [SequenceGeneratorOption]
-> Read SequenceGeneratorOption
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SequenceGeneratorOption
readsPrec :: Int -> ReadS SequenceGeneratorOption
$creadList :: ReadS [SequenceGeneratorOption]
readList :: ReadS [SequenceGeneratorOption]
$creadPrec :: ReadPrec SequenceGeneratorOption
readPrec :: ReadPrec SequenceGeneratorOption
$creadListPrec :: ReadPrec [SequenceGeneratorOption]
readListPrec :: ReadPrec [SequenceGeneratorOption]
Read,Typeable SequenceGeneratorOption
Typeable SequenceGeneratorOption =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> SequenceGeneratorOption
 -> c SequenceGeneratorOption)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SequenceGeneratorOption)
-> (SequenceGeneratorOption -> Constr)
-> (SequenceGeneratorOption -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SequenceGeneratorOption))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SequenceGeneratorOption))
-> ((forall b. Data b => b -> b)
    -> SequenceGeneratorOption -> SequenceGeneratorOption)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> SequenceGeneratorOption
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> SequenceGeneratorOption
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SequenceGeneratorOption -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u) -> SequenceGeneratorOption -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SequenceGeneratorOption -> m SequenceGeneratorOption)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SequenceGeneratorOption -> m SequenceGeneratorOption)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SequenceGeneratorOption -> m SequenceGeneratorOption)
-> Data SequenceGeneratorOption
SequenceGeneratorOption -> Constr
SequenceGeneratorOption -> DataType
(forall b. Data b => b -> b)
-> SequenceGeneratorOption -> SequenceGeneratorOption
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) -> SequenceGeneratorOption -> u
forall u.
(forall d. Data d => d -> u) -> SequenceGeneratorOption -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> SequenceGeneratorOption
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> SequenceGeneratorOption
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SequenceGeneratorOption -> m SequenceGeneratorOption
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SequenceGeneratorOption -> m SequenceGeneratorOption
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SequenceGeneratorOption
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SequenceGeneratorOption
-> c SequenceGeneratorOption
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SequenceGeneratorOption)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SequenceGeneratorOption)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SequenceGeneratorOption
-> c SequenceGeneratorOption
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SequenceGeneratorOption
-> c SequenceGeneratorOption
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SequenceGeneratorOption
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SequenceGeneratorOption
$ctoConstr :: SequenceGeneratorOption -> Constr
toConstr :: SequenceGeneratorOption -> Constr
$cdataTypeOf :: SequenceGeneratorOption -> DataType
dataTypeOf :: SequenceGeneratorOption -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SequenceGeneratorOption)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SequenceGeneratorOption)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SequenceGeneratorOption)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SequenceGeneratorOption)
$cgmapT :: (forall b. Data b => b -> b)
-> SequenceGeneratorOption -> SequenceGeneratorOption
gmapT :: (forall b. Data b => b -> b)
-> SequenceGeneratorOption -> SequenceGeneratorOption
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> SequenceGeneratorOption
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> SequenceGeneratorOption
-> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> SequenceGeneratorOption
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> SequenceGeneratorOption
-> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> SequenceGeneratorOption -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> SequenceGeneratorOption -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SequenceGeneratorOption -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SequenceGeneratorOption -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SequenceGeneratorOption -> m SequenceGeneratorOption
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SequenceGeneratorOption -> m SequenceGeneratorOption
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SequenceGeneratorOption -> m SequenceGeneratorOption
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SequenceGeneratorOption -> m SequenceGeneratorOption
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SequenceGeneratorOption -> m SequenceGeneratorOption
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SequenceGeneratorOption -> m SequenceGeneratorOption
Data,Typeable)

data CheckOption =
    DefaultCheckOption
  | CascadedCheckOption
  | LocalCheckOption
    deriving (CheckOption -> CheckOption -> Bool
(CheckOption -> CheckOption -> Bool)
-> (CheckOption -> CheckOption -> Bool) -> Eq CheckOption
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CheckOption -> CheckOption -> Bool
== :: CheckOption -> CheckOption -> Bool
$c/= :: CheckOption -> CheckOption -> Bool
/= :: CheckOption -> CheckOption -> Bool
Eq,Int -> CheckOption -> ShowS
[CheckOption] -> ShowS
CheckOption -> String
(Int -> CheckOption -> ShowS)
-> (CheckOption -> String)
-> ([CheckOption] -> ShowS)
-> Show CheckOption
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CheckOption -> ShowS
showsPrec :: Int -> CheckOption -> ShowS
$cshow :: CheckOption -> String
show :: CheckOption -> String
$cshowList :: [CheckOption] -> ShowS
showList :: [CheckOption] -> ShowS
Show,ReadPrec [CheckOption]
ReadPrec CheckOption
Int -> ReadS CheckOption
ReadS [CheckOption]
(Int -> ReadS CheckOption)
-> ReadS [CheckOption]
-> ReadPrec CheckOption
-> ReadPrec [CheckOption]
-> Read CheckOption
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CheckOption
readsPrec :: Int -> ReadS CheckOption
$creadList :: ReadS [CheckOption]
readList :: ReadS [CheckOption]
$creadPrec :: ReadPrec CheckOption
readPrec :: ReadPrec CheckOption
$creadListPrec :: ReadPrec [CheckOption]
readListPrec :: ReadPrec [CheckOption]
Read,Typeable CheckOption
Typeable CheckOption =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CheckOption -> c CheckOption)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CheckOption)
-> (CheckOption -> Constr)
-> (CheckOption -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CheckOption))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CheckOption))
-> ((forall b. Data b => b -> b) -> CheckOption -> CheckOption)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CheckOption -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CheckOption -> r)
-> (forall u. (forall d. Data d => d -> u) -> CheckOption -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CheckOption -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CheckOption -> m CheckOption)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CheckOption -> m CheckOption)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CheckOption -> m CheckOption)
-> Data CheckOption
CheckOption -> Constr
CheckOption -> DataType
(forall b. Data b => b -> b) -> CheckOption -> CheckOption
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) -> CheckOption -> u
forall u. (forall d. Data d => d -> u) -> CheckOption -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CheckOption -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CheckOption -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CheckOption -> m CheckOption
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CheckOption -> m CheckOption
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CheckOption
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CheckOption -> c CheckOption
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CheckOption)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CheckOption)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CheckOption -> c CheckOption
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CheckOption -> c CheckOption
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CheckOption
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CheckOption
$ctoConstr :: CheckOption -> Constr
toConstr :: CheckOption -> Constr
$cdataTypeOf :: CheckOption -> DataType
dataTypeOf :: CheckOption -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CheckOption)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CheckOption)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CheckOption)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CheckOption)
$cgmapT :: (forall b. Data b => b -> b) -> CheckOption -> CheckOption
gmapT :: (forall b. Data b => b -> b) -> CheckOption -> CheckOption
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CheckOption -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CheckOption -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CheckOption -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CheckOption -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CheckOption -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CheckOption -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CheckOption -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CheckOption -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CheckOption -> m CheckOption
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CheckOption -> m CheckOption
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CheckOption -> m CheckOption
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CheckOption -> m CheckOption
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CheckOption -> m CheckOption
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CheckOption -> m CheckOption
Data,Typeable)

data AlterDomainAction =
    ADSetDefault ScalarExpr
  | ADDropDefault
  | ADAddConstraint (Maybe [Name]) ScalarExpr
  | ADDropConstraint [Name]
    deriving (AlterDomainAction -> AlterDomainAction -> Bool
(AlterDomainAction -> AlterDomainAction -> Bool)
-> (AlterDomainAction -> AlterDomainAction -> Bool)
-> Eq AlterDomainAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AlterDomainAction -> AlterDomainAction -> Bool
== :: AlterDomainAction -> AlterDomainAction -> Bool
$c/= :: AlterDomainAction -> AlterDomainAction -> Bool
/= :: AlterDomainAction -> AlterDomainAction -> Bool
Eq,Int -> AlterDomainAction -> ShowS
[AlterDomainAction] -> ShowS
AlterDomainAction -> String
(Int -> AlterDomainAction -> ShowS)
-> (AlterDomainAction -> String)
-> ([AlterDomainAction] -> ShowS)
-> Show AlterDomainAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AlterDomainAction -> ShowS
showsPrec :: Int -> AlterDomainAction -> ShowS
$cshow :: AlterDomainAction -> String
show :: AlterDomainAction -> String
$cshowList :: [AlterDomainAction] -> ShowS
showList :: [AlterDomainAction] -> ShowS
Show,ReadPrec [AlterDomainAction]
ReadPrec AlterDomainAction
Int -> ReadS AlterDomainAction
ReadS [AlterDomainAction]
(Int -> ReadS AlterDomainAction)
-> ReadS [AlterDomainAction]
-> ReadPrec AlterDomainAction
-> ReadPrec [AlterDomainAction]
-> Read AlterDomainAction
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AlterDomainAction
readsPrec :: Int -> ReadS AlterDomainAction
$creadList :: ReadS [AlterDomainAction]
readList :: ReadS [AlterDomainAction]
$creadPrec :: ReadPrec AlterDomainAction
readPrec :: ReadPrec AlterDomainAction
$creadListPrec :: ReadPrec [AlterDomainAction]
readListPrec :: ReadPrec [AlterDomainAction]
Read,Typeable AlterDomainAction
Typeable AlterDomainAction =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> AlterDomainAction
 -> c AlterDomainAction)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AlterDomainAction)
-> (AlterDomainAction -> Constr)
-> (AlterDomainAction -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AlterDomainAction))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AlterDomainAction))
-> ((forall b. Data b => b -> b)
    -> AlterDomainAction -> AlterDomainAction)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AlterDomainAction -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AlterDomainAction -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> AlterDomainAction -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> AlterDomainAction -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AlterDomainAction -> m AlterDomainAction)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AlterDomainAction -> m AlterDomainAction)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AlterDomainAction -> m AlterDomainAction)
-> Data AlterDomainAction
AlterDomainAction -> Constr
AlterDomainAction -> DataType
(forall b. Data b => b -> b)
-> AlterDomainAction -> AlterDomainAction
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) -> AlterDomainAction -> u
forall u. (forall d. Data d => d -> u) -> AlterDomainAction -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlterDomainAction -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AlterDomainAction -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AlterDomainAction -> m AlterDomainAction
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AlterDomainAction -> m AlterDomainAction
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlterDomainAction
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlterDomainAction -> c AlterDomainAction
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlterDomainAction)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AlterDomainAction)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlterDomainAction -> c AlterDomainAction
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlterDomainAction -> c AlterDomainAction
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlterDomainAction
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlterDomainAction
$ctoConstr :: AlterDomainAction -> Constr
toConstr :: AlterDomainAction -> Constr
$cdataTypeOf :: AlterDomainAction -> DataType
dataTypeOf :: AlterDomainAction -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlterDomainAction)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlterDomainAction)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AlterDomainAction)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AlterDomainAction)
$cgmapT :: (forall b. Data b => b -> b)
-> AlterDomainAction -> AlterDomainAction
gmapT :: (forall b. Data b => b -> b)
-> AlterDomainAction -> AlterDomainAction
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlterDomainAction -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlterDomainAction -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AlterDomainAction -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AlterDomainAction -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AlterDomainAction -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AlterDomainAction -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> AlterDomainAction -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> AlterDomainAction -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AlterDomainAction -> m AlterDomainAction
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AlterDomainAction -> m AlterDomainAction
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AlterDomainAction -> m AlterDomainAction
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AlterDomainAction -> m AlterDomainAction
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AlterDomainAction -> m AlterDomainAction
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AlterDomainAction -> m AlterDomainAction
Data,Typeable)


data AdminOption = WithAdminOption | WithoutAdminOption
    deriving (AdminOption -> AdminOption -> Bool
(AdminOption -> AdminOption -> Bool)
-> (AdminOption -> AdminOption -> Bool) -> Eq AdminOption
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AdminOption -> AdminOption -> Bool
== :: AdminOption -> AdminOption -> Bool
$c/= :: AdminOption -> AdminOption -> Bool
/= :: AdminOption -> AdminOption -> Bool
Eq,Int -> AdminOption -> ShowS
[AdminOption] -> ShowS
AdminOption -> String
(Int -> AdminOption -> ShowS)
-> (AdminOption -> String)
-> ([AdminOption] -> ShowS)
-> Show AdminOption
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AdminOption -> ShowS
showsPrec :: Int -> AdminOption -> ShowS
$cshow :: AdminOption -> String
show :: AdminOption -> String
$cshowList :: [AdminOption] -> ShowS
showList :: [AdminOption] -> ShowS
Show,ReadPrec [AdminOption]
ReadPrec AdminOption
Int -> ReadS AdminOption
ReadS [AdminOption]
(Int -> ReadS AdminOption)
-> ReadS [AdminOption]
-> ReadPrec AdminOption
-> ReadPrec [AdminOption]
-> Read AdminOption
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AdminOption
readsPrec :: Int -> ReadS AdminOption
$creadList :: ReadS [AdminOption]
readList :: ReadS [AdminOption]
$creadPrec :: ReadPrec AdminOption
readPrec :: ReadPrec AdminOption
$creadListPrec :: ReadPrec [AdminOption]
readListPrec :: ReadPrec [AdminOption]
Read,Typeable AdminOption
Typeable AdminOption =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> AdminOption -> c AdminOption)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AdminOption)
-> (AdminOption -> Constr)
-> (AdminOption -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AdminOption))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AdminOption))
-> ((forall b. Data b => b -> b) -> AdminOption -> AdminOption)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AdminOption -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AdminOption -> r)
-> (forall u. (forall d. Data d => d -> u) -> AdminOption -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> AdminOption -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AdminOption -> m AdminOption)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AdminOption -> m AdminOption)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AdminOption -> m AdminOption)
-> Data AdminOption
AdminOption -> Constr
AdminOption -> DataType
(forall b. Data b => b -> b) -> AdminOption -> AdminOption
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) -> AdminOption -> u
forall u. (forall d. Data d => d -> u) -> AdminOption -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AdminOption -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AdminOption -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AdminOption -> m AdminOption
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AdminOption -> m AdminOption
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AdminOption
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AdminOption -> c AdminOption
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AdminOption)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AdminOption)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AdminOption -> c AdminOption
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AdminOption -> c AdminOption
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AdminOption
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AdminOption
$ctoConstr :: AdminOption -> Constr
toConstr :: AdminOption -> Constr
$cdataTypeOf :: AdminOption -> DataType
dataTypeOf :: AdminOption -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AdminOption)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AdminOption)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AdminOption)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AdminOption)
$cgmapT :: (forall b. Data b => b -> b) -> AdminOption -> AdminOption
gmapT :: (forall b. Data b => b -> b) -> AdminOption -> AdminOption
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AdminOption -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AdminOption -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AdminOption -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AdminOption -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AdminOption -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AdminOption -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AdminOption -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AdminOption -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AdminOption -> m AdminOption
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AdminOption -> m AdminOption
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AdminOption -> m AdminOption
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AdminOption -> m AdminOption
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AdminOption -> m AdminOption
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AdminOption -> m AdminOption
Data,Typeable)

data GrantOption = WithGrantOption | WithoutGrantOption
    deriving (GrantOption -> GrantOption -> Bool
(GrantOption -> GrantOption -> Bool)
-> (GrantOption -> GrantOption -> Bool) -> Eq GrantOption
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GrantOption -> GrantOption -> Bool
== :: GrantOption -> GrantOption -> Bool
$c/= :: GrantOption -> GrantOption -> Bool
/= :: GrantOption -> GrantOption -> Bool
Eq,Int -> GrantOption -> ShowS
[GrantOption] -> ShowS
GrantOption -> String
(Int -> GrantOption -> ShowS)
-> (GrantOption -> String)
-> ([GrantOption] -> ShowS)
-> Show GrantOption
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GrantOption -> ShowS
showsPrec :: Int -> GrantOption -> ShowS
$cshow :: GrantOption -> String
show :: GrantOption -> String
$cshowList :: [GrantOption] -> ShowS
showList :: [GrantOption] -> ShowS
Show,ReadPrec [GrantOption]
ReadPrec GrantOption
Int -> ReadS GrantOption
ReadS [GrantOption]
(Int -> ReadS GrantOption)
-> ReadS [GrantOption]
-> ReadPrec GrantOption
-> ReadPrec [GrantOption]
-> Read GrantOption
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS GrantOption
readsPrec :: Int -> ReadS GrantOption
$creadList :: ReadS [GrantOption]
readList :: ReadS [GrantOption]
$creadPrec :: ReadPrec GrantOption
readPrec :: ReadPrec GrantOption
$creadListPrec :: ReadPrec [GrantOption]
readListPrec :: ReadPrec [GrantOption]
Read,Typeable GrantOption
Typeable GrantOption =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GrantOption -> c GrantOption)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GrantOption)
-> (GrantOption -> Constr)
-> (GrantOption -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GrantOption))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GrantOption))
-> ((forall b. Data b => b -> b) -> GrantOption -> GrantOption)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GrantOption -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GrantOption -> r)
-> (forall u. (forall d. Data d => d -> u) -> GrantOption -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GrantOption -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GrantOption -> m GrantOption)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GrantOption -> m GrantOption)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GrantOption -> m GrantOption)
-> Data GrantOption
GrantOption -> Constr
GrantOption -> DataType
(forall b. Data b => b -> b) -> GrantOption -> GrantOption
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) -> GrantOption -> u
forall u. (forall d. Data d => d -> u) -> GrantOption -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GrantOption -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GrantOption -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GrantOption -> m GrantOption
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GrantOption -> m GrantOption
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GrantOption
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GrantOption -> c GrantOption
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GrantOption)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GrantOption)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GrantOption -> c GrantOption
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GrantOption -> c GrantOption
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GrantOption
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GrantOption
$ctoConstr :: GrantOption -> Constr
toConstr :: GrantOption -> Constr
$cdataTypeOf :: GrantOption -> DataType
dataTypeOf :: GrantOption -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GrantOption)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GrantOption)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GrantOption)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GrantOption)
$cgmapT :: (forall b. Data b => b -> b) -> GrantOption -> GrantOption
gmapT :: (forall b. Data b => b -> b) -> GrantOption -> GrantOption
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GrantOption -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GrantOption -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GrantOption -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GrantOption -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GrantOption -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GrantOption -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GrantOption -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GrantOption -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GrantOption -> m GrantOption
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GrantOption -> m GrantOption
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GrantOption -> m GrantOption
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GrantOption -> m GrantOption
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GrantOption -> m GrantOption
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GrantOption -> m GrantOption
Data,Typeable)

data AdminOptionFor = AdminOptionFor | NoAdminOptionFor
    deriving (AdminOptionFor -> AdminOptionFor -> Bool
(AdminOptionFor -> AdminOptionFor -> Bool)
-> (AdminOptionFor -> AdminOptionFor -> Bool) -> Eq AdminOptionFor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AdminOptionFor -> AdminOptionFor -> Bool
== :: AdminOptionFor -> AdminOptionFor -> Bool
$c/= :: AdminOptionFor -> AdminOptionFor -> Bool
/= :: AdminOptionFor -> AdminOptionFor -> Bool
Eq,Int -> AdminOptionFor -> ShowS
[AdminOptionFor] -> ShowS
AdminOptionFor -> String
(Int -> AdminOptionFor -> ShowS)
-> (AdminOptionFor -> String)
-> ([AdminOptionFor] -> ShowS)
-> Show AdminOptionFor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AdminOptionFor -> ShowS
showsPrec :: Int -> AdminOptionFor -> ShowS
$cshow :: AdminOptionFor -> String
show :: AdminOptionFor -> String
$cshowList :: [AdminOptionFor] -> ShowS
showList :: [AdminOptionFor] -> ShowS
Show,ReadPrec [AdminOptionFor]
ReadPrec AdminOptionFor
Int -> ReadS AdminOptionFor
ReadS [AdminOptionFor]
(Int -> ReadS AdminOptionFor)
-> ReadS [AdminOptionFor]
-> ReadPrec AdminOptionFor
-> ReadPrec [AdminOptionFor]
-> Read AdminOptionFor
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AdminOptionFor
readsPrec :: Int -> ReadS AdminOptionFor
$creadList :: ReadS [AdminOptionFor]
readList :: ReadS [AdminOptionFor]
$creadPrec :: ReadPrec AdminOptionFor
readPrec :: ReadPrec AdminOptionFor
$creadListPrec :: ReadPrec [AdminOptionFor]
readListPrec :: ReadPrec [AdminOptionFor]
Read,Typeable AdminOptionFor
Typeable AdminOptionFor =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> AdminOptionFor -> c AdminOptionFor)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AdminOptionFor)
-> (AdminOptionFor -> Constr)
-> (AdminOptionFor -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AdminOptionFor))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AdminOptionFor))
-> ((forall b. Data b => b -> b)
    -> AdminOptionFor -> AdminOptionFor)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AdminOptionFor -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AdminOptionFor -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> AdminOptionFor -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> AdminOptionFor -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> AdminOptionFor -> m AdminOptionFor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AdminOptionFor -> m AdminOptionFor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> AdminOptionFor -> m AdminOptionFor)
-> Data AdminOptionFor
AdminOptionFor -> Constr
AdminOptionFor -> DataType
(forall b. Data b => b -> b) -> AdminOptionFor -> AdminOptionFor
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) -> AdminOptionFor -> u
forall u. (forall d. Data d => d -> u) -> AdminOptionFor -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AdminOptionFor -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AdminOptionFor -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AdminOptionFor -> m AdminOptionFor
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AdminOptionFor -> m AdminOptionFor
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AdminOptionFor
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AdminOptionFor -> c AdminOptionFor
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AdminOptionFor)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AdminOptionFor)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AdminOptionFor -> c AdminOptionFor
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AdminOptionFor -> c AdminOptionFor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AdminOptionFor
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AdminOptionFor
$ctoConstr :: AdminOptionFor -> Constr
toConstr :: AdminOptionFor -> Constr
$cdataTypeOf :: AdminOptionFor -> DataType
dataTypeOf :: AdminOptionFor -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AdminOptionFor)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AdminOptionFor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AdminOptionFor)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AdminOptionFor)
$cgmapT :: (forall b. Data b => b -> b) -> AdminOptionFor -> AdminOptionFor
gmapT :: (forall b. Data b => b -> b) -> AdminOptionFor -> AdminOptionFor
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AdminOptionFor -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AdminOptionFor -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AdminOptionFor -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AdminOptionFor -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AdminOptionFor -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AdminOptionFor -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> AdminOptionFor -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> AdminOptionFor -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AdminOptionFor -> m AdminOptionFor
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AdminOptionFor -> m AdminOptionFor
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AdminOptionFor -> m AdminOptionFor
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AdminOptionFor -> m AdminOptionFor
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AdminOptionFor -> m AdminOptionFor
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> AdminOptionFor -> m AdminOptionFor
Data,Typeable)

data GrantOptionFor = GrantOptionFor | NoGrantOptionFor
    deriving (GrantOptionFor -> GrantOptionFor -> Bool
(GrantOptionFor -> GrantOptionFor -> Bool)
-> (GrantOptionFor -> GrantOptionFor -> Bool) -> Eq GrantOptionFor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GrantOptionFor -> GrantOptionFor -> Bool
== :: GrantOptionFor -> GrantOptionFor -> Bool
$c/= :: GrantOptionFor -> GrantOptionFor -> Bool
/= :: GrantOptionFor -> GrantOptionFor -> Bool
Eq,Int -> GrantOptionFor -> ShowS
[GrantOptionFor] -> ShowS
GrantOptionFor -> String
(Int -> GrantOptionFor -> ShowS)
-> (GrantOptionFor -> String)
-> ([GrantOptionFor] -> ShowS)
-> Show GrantOptionFor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GrantOptionFor -> ShowS
showsPrec :: Int -> GrantOptionFor -> ShowS
$cshow :: GrantOptionFor -> String
show :: GrantOptionFor -> String
$cshowList :: [GrantOptionFor] -> ShowS
showList :: [GrantOptionFor] -> ShowS
Show,ReadPrec [GrantOptionFor]
ReadPrec GrantOptionFor
Int -> ReadS GrantOptionFor
ReadS [GrantOptionFor]
(Int -> ReadS GrantOptionFor)
-> ReadS [GrantOptionFor]
-> ReadPrec GrantOptionFor
-> ReadPrec [GrantOptionFor]
-> Read GrantOptionFor
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS GrantOptionFor
readsPrec :: Int -> ReadS GrantOptionFor
$creadList :: ReadS [GrantOptionFor]
readList :: ReadS [GrantOptionFor]
$creadPrec :: ReadPrec GrantOptionFor
readPrec :: ReadPrec GrantOptionFor
$creadListPrec :: ReadPrec [GrantOptionFor]
readListPrec :: ReadPrec [GrantOptionFor]
Read,Typeable GrantOptionFor
Typeable GrantOptionFor =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GrantOptionFor -> c GrantOptionFor)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GrantOptionFor)
-> (GrantOptionFor -> Constr)
-> (GrantOptionFor -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GrantOptionFor))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GrantOptionFor))
-> ((forall b. Data b => b -> b)
    -> GrantOptionFor -> GrantOptionFor)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GrantOptionFor -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GrantOptionFor -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> GrantOptionFor -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GrantOptionFor -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> GrantOptionFor -> m GrantOptionFor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GrantOptionFor -> m GrantOptionFor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GrantOptionFor -> m GrantOptionFor)
-> Data GrantOptionFor
GrantOptionFor -> Constr
GrantOptionFor -> DataType
(forall b. Data b => b -> b) -> GrantOptionFor -> GrantOptionFor
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) -> GrantOptionFor -> u
forall u. (forall d. Data d => d -> u) -> GrantOptionFor -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GrantOptionFor -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GrantOptionFor -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GrantOptionFor -> m GrantOptionFor
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GrantOptionFor -> m GrantOptionFor
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GrantOptionFor
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GrantOptionFor -> c GrantOptionFor
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GrantOptionFor)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GrantOptionFor)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GrantOptionFor -> c GrantOptionFor
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GrantOptionFor -> c GrantOptionFor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GrantOptionFor
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GrantOptionFor
$ctoConstr :: GrantOptionFor -> Constr
toConstr :: GrantOptionFor -> Constr
$cdataTypeOf :: GrantOptionFor -> DataType
dataTypeOf :: GrantOptionFor -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GrantOptionFor)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GrantOptionFor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GrantOptionFor)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GrantOptionFor)
$cgmapT :: (forall b. Data b => b -> b) -> GrantOptionFor -> GrantOptionFor
gmapT :: (forall b. Data b => b -> b) -> GrantOptionFor -> GrantOptionFor
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GrantOptionFor -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GrantOptionFor -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GrantOptionFor -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GrantOptionFor -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GrantOptionFor -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GrantOptionFor -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> GrantOptionFor -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> GrantOptionFor -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GrantOptionFor -> m GrantOptionFor
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GrantOptionFor -> m GrantOptionFor
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GrantOptionFor -> m GrantOptionFor
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GrantOptionFor -> m GrantOptionFor
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GrantOptionFor -> m GrantOptionFor
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GrantOptionFor -> m GrantOptionFor
Data,Typeable)

data PrivilegeObject =
      PrivTable [Name]
    | PrivDomain [Name]
    | PrivType [Name]
    | PrivSequence [Name]
    | PrivFunction [Name]
    deriving (PrivilegeObject -> PrivilegeObject -> Bool
(PrivilegeObject -> PrivilegeObject -> Bool)
-> (PrivilegeObject -> PrivilegeObject -> Bool)
-> Eq PrivilegeObject
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PrivilegeObject -> PrivilegeObject -> Bool
== :: PrivilegeObject -> PrivilegeObject -> Bool
$c/= :: PrivilegeObject -> PrivilegeObject -> Bool
/= :: PrivilegeObject -> PrivilegeObject -> Bool
Eq,Int -> PrivilegeObject -> ShowS
[PrivilegeObject] -> ShowS
PrivilegeObject -> String
(Int -> PrivilegeObject -> ShowS)
-> (PrivilegeObject -> String)
-> ([PrivilegeObject] -> ShowS)
-> Show PrivilegeObject
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PrivilegeObject -> ShowS
showsPrec :: Int -> PrivilegeObject -> ShowS
$cshow :: PrivilegeObject -> String
show :: PrivilegeObject -> String
$cshowList :: [PrivilegeObject] -> ShowS
showList :: [PrivilegeObject] -> ShowS
Show,ReadPrec [PrivilegeObject]
ReadPrec PrivilegeObject
Int -> ReadS PrivilegeObject
ReadS [PrivilegeObject]
(Int -> ReadS PrivilegeObject)
-> ReadS [PrivilegeObject]
-> ReadPrec PrivilegeObject
-> ReadPrec [PrivilegeObject]
-> Read PrivilegeObject
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PrivilegeObject
readsPrec :: Int -> ReadS PrivilegeObject
$creadList :: ReadS [PrivilegeObject]
readList :: ReadS [PrivilegeObject]
$creadPrec :: ReadPrec PrivilegeObject
readPrec :: ReadPrec PrivilegeObject
$creadListPrec :: ReadPrec [PrivilegeObject]
readListPrec :: ReadPrec [PrivilegeObject]
Read,Typeable PrivilegeObject
Typeable PrivilegeObject =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PrivilegeObject -> c PrivilegeObject)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PrivilegeObject)
-> (PrivilegeObject -> Constr)
-> (PrivilegeObject -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PrivilegeObject))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c PrivilegeObject))
-> ((forall b. Data b => b -> b)
    -> PrivilegeObject -> PrivilegeObject)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PrivilegeObject -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PrivilegeObject -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> PrivilegeObject -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PrivilegeObject -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PrivilegeObject -> m PrivilegeObject)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PrivilegeObject -> m PrivilegeObject)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PrivilegeObject -> m PrivilegeObject)
-> Data PrivilegeObject
PrivilegeObject -> Constr
PrivilegeObject -> DataType
(forall b. Data b => b -> b) -> PrivilegeObject -> PrivilegeObject
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) -> PrivilegeObject -> u
forall u. (forall d. Data d => d -> u) -> PrivilegeObject -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrivilegeObject -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrivilegeObject -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PrivilegeObject -> m PrivilegeObject
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrivilegeObject -> m PrivilegeObject
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrivilegeObject
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrivilegeObject -> c PrivilegeObject
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrivilegeObject)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrivilegeObject)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrivilegeObject -> c PrivilegeObject
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrivilegeObject -> c PrivilegeObject
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrivilegeObject
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrivilegeObject
$ctoConstr :: PrivilegeObject -> Constr
toConstr :: PrivilegeObject -> Constr
$cdataTypeOf :: PrivilegeObject -> DataType
dataTypeOf :: PrivilegeObject -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrivilegeObject)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrivilegeObject)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrivilegeObject)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrivilegeObject)
$cgmapT :: (forall b. Data b => b -> b) -> PrivilegeObject -> PrivilegeObject
gmapT :: (forall b. Data b => b -> b) -> PrivilegeObject -> PrivilegeObject
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrivilegeObject -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrivilegeObject -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrivilegeObject -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrivilegeObject -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PrivilegeObject -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PrivilegeObject -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PrivilegeObject -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PrivilegeObject -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PrivilegeObject -> m PrivilegeObject
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PrivilegeObject -> m PrivilegeObject
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrivilegeObject -> m PrivilegeObject
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrivilegeObject -> m PrivilegeObject
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrivilegeObject -> m PrivilegeObject
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrivilegeObject -> m PrivilegeObject
Data,Typeable)

data PrivilegeAction =
      PrivAll
    | PrivSelect [Name]
    | PrivDelete
    | PrivInsert [Name]
    | PrivUpdate [Name]
    | PrivReferences [Name]
    | PrivUsage
    | PrivTrigger
    | PrivExecute
    deriving (PrivilegeAction -> PrivilegeAction -> Bool
(PrivilegeAction -> PrivilegeAction -> Bool)
-> (PrivilegeAction -> PrivilegeAction -> Bool)
-> Eq PrivilegeAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PrivilegeAction -> PrivilegeAction -> Bool
== :: PrivilegeAction -> PrivilegeAction -> Bool
$c/= :: PrivilegeAction -> PrivilegeAction -> Bool
/= :: PrivilegeAction -> PrivilegeAction -> Bool
Eq,Int -> PrivilegeAction -> ShowS
[PrivilegeAction] -> ShowS
PrivilegeAction -> String
(Int -> PrivilegeAction -> ShowS)
-> (PrivilegeAction -> String)
-> ([PrivilegeAction] -> ShowS)
-> Show PrivilegeAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PrivilegeAction -> ShowS
showsPrec :: Int -> PrivilegeAction -> ShowS
$cshow :: PrivilegeAction -> String
show :: PrivilegeAction -> String
$cshowList :: [PrivilegeAction] -> ShowS
showList :: [PrivilegeAction] -> ShowS
Show,ReadPrec [PrivilegeAction]
ReadPrec PrivilegeAction
Int -> ReadS PrivilegeAction
ReadS [PrivilegeAction]
(Int -> ReadS PrivilegeAction)
-> ReadS [PrivilegeAction]
-> ReadPrec PrivilegeAction
-> ReadPrec [PrivilegeAction]
-> Read PrivilegeAction
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PrivilegeAction
readsPrec :: Int -> ReadS PrivilegeAction
$creadList :: ReadS [PrivilegeAction]
readList :: ReadS [PrivilegeAction]
$creadPrec :: ReadPrec PrivilegeAction
readPrec :: ReadPrec PrivilegeAction
$creadListPrec :: ReadPrec [PrivilegeAction]
readListPrec :: ReadPrec [PrivilegeAction]
Read,Typeable PrivilegeAction
Typeable PrivilegeAction =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PrivilegeAction -> c PrivilegeAction)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PrivilegeAction)
-> (PrivilegeAction -> Constr)
-> (PrivilegeAction -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PrivilegeAction))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c PrivilegeAction))
-> ((forall b. Data b => b -> b)
    -> PrivilegeAction -> PrivilegeAction)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PrivilegeAction -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PrivilegeAction -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> PrivilegeAction -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PrivilegeAction -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PrivilegeAction -> m PrivilegeAction)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PrivilegeAction -> m PrivilegeAction)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PrivilegeAction -> m PrivilegeAction)
-> Data PrivilegeAction
PrivilegeAction -> Constr
PrivilegeAction -> DataType
(forall b. Data b => b -> b) -> PrivilegeAction -> PrivilegeAction
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) -> PrivilegeAction -> u
forall u. (forall d. Data d => d -> u) -> PrivilegeAction -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrivilegeAction -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrivilegeAction -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PrivilegeAction -> m PrivilegeAction
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrivilegeAction -> m PrivilegeAction
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrivilegeAction
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrivilegeAction -> c PrivilegeAction
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrivilegeAction)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrivilegeAction)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrivilegeAction -> c PrivilegeAction
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrivilegeAction -> c PrivilegeAction
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrivilegeAction
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrivilegeAction
$ctoConstr :: PrivilegeAction -> Constr
toConstr :: PrivilegeAction -> Constr
$cdataTypeOf :: PrivilegeAction -> DataType
dataTypeOf :: PrivilegeAction -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrivilegeAction)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrivilegeAction)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrivilegeAction)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrivilegeAction)
$cgmapT :: (forall b. Data b => b -> b) -> PrivilegeAction -> PrivilegeAction
gmapT :: (forall b. Data b => b -> b) -> PrivilegeAction -> PrivilegeAction
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrivilegeAction -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrivilegeAction -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrivilegeAction -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrivilegeAction -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PrivilegeAction -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PrivilegeAction -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PrivilegeAction -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PrivilegeAction -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PrivilegeAction -> m PrivilegeAction
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PrivilegeAction -> m PrivilegeAction
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrivilegeAction -> m PrivilegeAction
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrivilegeAction -> m PrivilegeAction
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrivilegeAction -> m PrivilegeAction
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PrivilegeAction -> m PrivilegeAction
Data,Typeable)

-- | Comment. Useful when generating SQL code programmatically. The
-- parser doesn't produce these.
newtype Comment = BlockComment Text
               deriving (Comment -> Comment -> Bool
(Comment -> Comment -> Bool)
-> (Comment -> Comment -> Bool) -> Eq Comment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Comment -> Comment -> Bool
== :: Comment -> Comment -> Bool
$c/= :: Comment -> Comment -> Bool
/= :: Comment -> Comment -> Bool
Eq,Int -> Comment -> ShowS
[Comment] -> ShowS
Comment -> String
(Int -> Comment -> ShowS)
-> (Comment -> String) -> ([Comment] -> ShowS) -> Show Comment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Comment -> ShowS
showsPrec :: Int -> Comment -> ShowS
$cshow :: Comment -> String
show :: Comment -> String
$cshowList :: [Comment] -> ShowS
showList :: [Comment] -> ShowS
Show,ReadPrec [Comment]
ReadPrec Comment
Int -> ReadS Comment
ReadS [Comment]
(Int -> ReadS Comment)
-> ReadS [Comment]
-> ReadPrec Comment
-> ReadPrec [Comment]
-> Read Comment
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Comment
readsPrec :: Int -> ReadS Comment
$creadList :: ReadS [Comment]
readList :: ReadS [Comment]
$creadPrec :: ReadPrec Comment
readPrec :: ReadPrec Comment
$creadListPrec :: ReadPrec [Comment]
readListPrec :: ReadPrec [Comment]
Read,Typeable Comment
Typeable Comment =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Comment -> c Comment)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Comment)
-> (Comment -> Constr)
-> (Comment -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Comment))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Comment))
-> ((forall b. Data b => b -> b) -> Comment -> Comment)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Comment -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Comment -> r)
-> (forall u. (forall d. Data d => d -> u) -> Comment -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Comment -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Comment -> m Comment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Comment -> m Comment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Comment -> m Comment)
-> Data Comment
Comment -> Constr
Comment -> DataType
(forall b. Data b => b -> b) -> Comment -> Comment
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) -> Comment -> u
forall u. (forall d. Data d => d -> u) -> Comment -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Comment
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Comment -> c Comment
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Comment)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Comment)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Comment -> c Comment
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Comment -> c Comment
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Comment
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Comment
$ctoConstr :: Comment -> Constr
toConstr :: Comment -> Constr
$cdataTypeOf :: Comment -> DataType
dataTypeOf :: Comment -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Comment)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Comment)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Comment)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Comment)
$cgmapT :: (forall b. Data b => b -> b) -> Comment -> Comment
gmapT :: (forall b. Data b => b -> b) -> Comment -> Comment
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Comment -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Comment -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Comment -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Comment -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
Data,Typeable)

data MakeSelect
    = MakeSelect
    {MakeSelect -> SetQuantifier
msSetQuantifier :: SetQuantifier
    ,MakeSelect -> [(ScalarExpr, Maybe Name)]
msSelectList :: [(ScalarExpr,Maybe Name)]
    ,MakeSelect -> [TableRef]
msFrom :: [TableRef]
    ,MakeSelect -> Maybe ScalarExpr
msWhere :: Maybe ScalarExpr
    ,MakeSelect -> [GroupingExpr]
msGroupBy :: [GroupingExpr]
    ,MakeSelect -> Maybe ScalarExpr
msHaving :: Maybe ScalarExpr
    ,MakeSelect -> [SortSpec]
msOrderBy :: [SortSpec]
    ,MakeSelect -> Maybe ScalarExpr
msOffset :: Maybe ScalarExpr
    ,MakeSelect -> Maybe ScalarExpr
msFetchFirst :: Maybe ScalarExpr
    }

-- | Helper/'default' value for query exprs to make creating query
-- expr values a little easier. It is defined like this:
--
-- > makeSelect :: MakeSelect
-- > makeSelect
-- >     = MakeSelect
-- >     {msSetQuantifier = SQDefault
-- >     ,msSelectList = []
-- >     ,msFrom = []
-- >     ,msWhere = Nothing
-- >     ,msGroupBy = []
-- >     ,msHaving = Nothing
-- >     ,msOrderBy = []
-- >     ,msOffset = Nothing
-- >     ,msFetchFirst = Nothing}
-- >
-- > Example, to create a select query expression with a select list 'sl':
-- >   toQueryExpr $ makeSelect {msSelectList = sl}

makeSelect :: MakeSelect
makeSelect :: MakeSelect
makeSelect
    = MakeSelect
    {msSetQuantifier :: SetQuantifier
msSetQuantifier = SetQuantifier
SQDefault
    ,msSelectList :: [(ScalarExpr, Maybe Name)]
msSelectList = []
    ,msFrom :: [TableRef]
msFrom = []
    ,msWhere :: Maybe ScalarExpr
msWhere = Maybe ScalarExpr
forall a. Maybe a
Nothing
    ,msGroupBy :: [GroupingExpr]
msGroupBy = []
    ,msHaving :: Maybe ScalarExpr
msHaving = Maybe ScalarExpr
forall a. Maybe a
Nothing
    ,msOrderBy :: [SortSpec]
msOrderBy = []
    ,msOffset :: Maybe ScalarExpr
msOffset = Maybe ScalarExpr
forall a. Maybe a
Nothing
    ,msFetchFirst :: Maybe ScalarExpr
msFetchFirst = Maybe ScalarExpr
forall a. Maybe a
Nothing}

toQueryExpr :: MakeSelect -> QueryExpr
toQueryExpr :: MakeSelect -> QueryExpr
toQueryExpr (MakeSelect SetQuantifier
q [(ScalarExpr, Maybe Name)]
sl [TableRef]
f Maybe ScalarExpr
w [GroupingExpr]
g Maybe ScalarExpr
h [SortSpec]
o Maybe ScalarExpr
ff Maybe ScalarExpr
fetch) = SetQuantifier
-> [(ScalarExpr, Maybe Name)]
-> [TableRef]
-> Maybe ScalarExpr
-> [GroupingExpr]
-> Maybe ScalarExpr
-> [SortSpec]
-> Maybe ScalarExpr
-> Maybe ScalarExpr
-> QueryExpr
Select SetQuantifier
q [(ScalarExpr, Maybe Name)]
sl [TableRef]
f Maybe ScalarExpr
w [GroupingExpr]
g Maybe ScalarExpr
h [SortSpec]
o Maybe ScalarExpr
ff Maybe ScalarExpr
fetch