> -- | 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(..)
>     ,makeSelect
>     ,SetOperatorName(..)
>     ,Corresponding(..)
>     ,Alias(..)
>     ,GroupingExpr(..)
>      -- ** From
>     ,TableRef(..)
>     ,JoinType(..)
>     ,JoinCondition(..)
>      -- * Statements
>     ,Statement(..)
>     ,DropBehaviour(..)
>     ,IdentityRestart(..)
>     ,InsertSource(..)
>     ,SetClause(..)
>     ,TableElement(..)
>     ,ColumnDef(..)
>     ,DefaultClause(..)
>     ,IdentityWhen(..)
>     ,SequenceGeneratorOption(..)
>     ,ColConstraintDef(..)
>     ,ColConstraint(..)
>     ,TableConstraint(..)
>     ,ReferenceMatch(..)
>     ,ReferentialAction(..)
>     ,AlterTableAction(..)
>     ,CheckOption(..)
>     ,AlterDomainAction(..)
>     ,AdminOption(..)
>     ,GrantOption(..)
>     ,PrivilegeObject(..)
>     ,PrivilegeAction(..)
>     ,AdminOptionFor(..)
>     ,GrantOptionFor(..)
>      -- * Comment
>     ,Comment(..)
>     ) where

> import Data.Data

> -- | 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 String
>       -- | string literal, with the start and end quote
>       -- e.g. 'test' -> StringLit "'" "'" "test"
>     | StringLit String String String
>       -- | 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 -> String
ilLiteral :: String -- ^ literal text
>       ,ScalarExpr -> IntervalTypeField
ilFrom :: IntervalTypeField
>       ,ScalarExpr -> Maybe IntervalTypeField
ilTo :: Maybe IntervalTypeField
>       }

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

>       -- | 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 String (Maybe String) -- ^ represents a host
>                                           -- parameter, e.g. :a. The
>                                           -- Maybe String 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) [(String,ScalarExpr)]

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

>       -- | 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 String
>       -- ^ 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
/= :: ScalarExpr -> ScalarExpr -> Bool
$c/= :: ScalarExpr -> ScalarExpr -> Bool
== :: ScalarExpr -> ScalarExpr -> Bool
$c== :: 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
showList :: [ScalarExpr] -> ShowS
$cshowList :: [ScalarExpr] -> ShowS
show :: ScalarExpr -> String
$cshow :: ScalarExpr -> String
showsPrec :: Int -> ScalarExpr -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [ScalarExpr]
$creadListPrec :: ReadPrec [ScalarExpr]
readPrec :: ReadPrec ScalarExpr
$creadPrec :: ReadPrec ScalarExpr
readList :: ReadS [ScalarExpr]
$creadList :: ReadS [ScalarExpr]
readsPrec :: Int -> ReadS ScalarExpr
$creadsPrec :: Int -> ReadS ScalarExpr
Read,Typeable ScalarExpr
DataType
Constr
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 -> DataType
ScalarExpr -> Constr
(forall b. Data b => b -> b) -> ScalarExpr -> ScalarExpr
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ScalarExpr -> c ScalarExpr
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cOdbcFunc :: Constr
$cOdbcLiteral :: Constr
$cVEComment :: Constr
$cNextValueFor :: Constr
$cMultisetQueryCtor :: Constr
$cMultisetCtor :: Constr
$cMultisetBinOp :: Constr
$cCollate :: Constr
$cArrayCtor :: Constr
$cArray :: Constr
$cMatch :: Constr
$cQuantifiedComparison :: Constr
$cSubQueryExpr :: Constr
$cIn :: Constr
$cParens :: Constr
$cCase :: Constr
$cCast :: Constr
$cSpecialOpK :: Constr
$cWindowApp :: Constr
$cAggregateAppGroup :: Constr
$cAggregateApp :: Constr
$cApp :: Constr
$cSpecialOp :: Constr
$cPostfixOp :: Constr
$cPrefixOp :: Constr
$cBinOp :: Constr
$cHostParameter :: Constr
$cPositionalArg :: Constr
$cParameter :: Constr
$cStar :: Constr
$cIden :: Constr
$cTypedLit :: Constr
$cIntervalLit :: Constr
$cStringLit :: Constr
$cNumLit :: Constr
$tScalarExpr :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr
gmapQi :: Int -> (forall d. Data d => d -> u) -> ScalarExpr -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ScalarExpr -> u
gmapQ :: (forall d. Data d => d -> u) -> ScalarExpr -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ScalarExpr -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ScalarExpr -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ScalarExpr -> r
gmapT :: (forall b. Data b => b -> b) -> ScalarExpr -> ScalarExpr
$cgmapT :: (forall b. Data b => b -> b) -> ScalarExpr -> ScalarExpr
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ScalarExpr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ScalarExpr)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ScalarExpr)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ScalarExpr)
dataTypeOf :: ScalarExpr -> DataType
$cdataTypeOf :: ScalarExpr -> DataType
toConstr :: ScalarExpr -> Constr
$ctoConstr :: ScalarExpr -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ScalarExpr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ScalarExpr
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ScalarExpr -> c ScalarExpr
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ScalarExpr -> c ScalarExpr
$cp1Data :: Typeable 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 (String,String)) String
>             deriving (Name -> Name -> Bool
(Name -> Name -> Bool) -> (Name -> Name -> Bool) -> Eq Name
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c== :: 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
showList :: [Name] -> ShowS
$cshowList :: [Name] -> ShowS
show :: Name -> String
$cshow :: Name -> String
showsPrec :: Int -> Name -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [Name]
$creadListPrec :: ReadPrec [Name]
readPrec :: ReadPrec Name
$creadPrec :: ReadPrec Name
readList :: ReadS [Name]
$creadList :: ReadS [Name]
readsPrec :: Int -> ReadS Name
$creadsPrec :: Int -> ReadS Name
Read,Typeable Name
DataType
Constr
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 -> DataType
Name -> Constr
(forall b. Data b => b -> b) -> Name -> Name
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cName :: Constr
$tName :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
gmapQ :: (forall d. Data d => d -> u) -> Name -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Name -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapT :: (forall b. Data b => b -> b) -> Name -> Name
$cgmapT :: (forall b. Data b => b -> b) -> Name -> Name
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Name)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
dataTypeOf :: Name -> DataType
$cdataTypeOf :: Name -> DataType
toConstr :: Name -> Constr
$ctoConstr :: Name -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cp1Data :: Typeable 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
/= :: TypeName -> TypeName -> Bool
$c/= :: TypeName -> TypeName -> Bool
== :: TypeName -> TypeName -> Bool
$c== :: 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
showList :: [TypeName] -> ShowS
$cshowList :: [TypeName] -> ShowS
show :: TypeName -> String
$cshow :: TypeName -> String
showsPrec :: Int -> TypeName -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [TypeName]
$creadListPrec :: ReadPrec [TypeName]
readPrec :: ReadPrec TypeName
$creadPrec :: ReadPrec TypeName
readList :: ReadS [TypeName]
$creadList :: ReadS [TypeName]
readsPrec :: Int -> ReadS TypeName
$creadsPrec :: Int -> ReadS TypeName
Read,Typeable TypeName
DataType
Constr
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 -> DataType
TypeName -> Constr
(forall b. Data b => b -> b) -> TypeName -> TypeName
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeName -> c TypeName
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cMultisetTypeName :: Constr
$cArrayTypeName :: Constr
$cIntervalTypeName :: Constr
$cRowTypeName :: Constr
$cTimeTypeName :: Constr
$cCharTypeName :: Constr
$cPrecLengthTypeName :: Constr
$cPrecScaleTypeName :: Constr
$cPrecTypeName :: Constr
$cTypeName :: Constr
$tTypeName :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> TypeName -> m TypeName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeName -> m TypeName
gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeName -> u
gmapQ :: (forall d. Data d => d -> u) -> TypeName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeName -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeName -> r
gmapT :: (forall b. Data b => b -> b) -> TypeName -> TypeName
$cgmapT :: (forall b. Data b => b -> b) -> TypeName -> TypeName
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeName)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TypeName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeName)
dataTypeOf :: TypeName -> DataType
$cdataTypeOf :: TypeName -> DataType
toConstr :: TypeName -> Constr
$ctoConstr :: TypeName -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeName
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeName -> c TypeName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeName -> c TypeName
$cp1Data :: Typeable TypeName
Data,Typeable)

> data IntervalTypeField = Itf String (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
/= :: IntervalTypeField -> IntervalTypeField -> Bool
$c/= :: IntervalTypeField -> IntervalTypeField -> Bool
== :: IntervalTypeField -> IntervalTypeField -> Bool
$c== :: 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
showList :: [IntervalTypeField] -> ShowS
$cshowList :: [IntervalTypeField] -> ShowS
show :: IntervalTypeField -> String
$cshow :: IntervalTypeField -> String
showsPrec :: Int -> IntervalTypeField -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [IntervalTypeField]
$creadListPrec :: ReadPrec [IntervalTypeField]
readPrec :: ReadPrec IntervalTypeField
$creadPrec :: ReadPrec IntervalTypeField
readList :: ReadS [IntervalTypeField]
$creadList :: ReadS [IntervalTypeField]
readsPrec :: Int -> ReadS IntervalTypeField
$creadsPrec :: Int -> ReadS IntervalTypeField
Read,Typeable IntervalTypeField
DataType
Constr
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 -> DataType
IntervalTypeField -> Constr
(forall b. Data b => b -> b)
-> IntervalTypeField -> IntervalTypeField
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IntervalTypeField -> c IntervalTypeField
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cItf :: Constr
$tIntervalTypeField :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> IntervalTypeField -> m IntervalTypeField
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> IntervalTypeField -> m IntervalTypeField
gmapQi :: Int -> (forall d. Data d => d -> u) -> IntervalTypeField -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> IntervalTypeField -> u
gmapQ :: (forall d. Data d => d -> u) -> IntervalTypeField -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IntervalTypeField -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IntervalTypeField -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IntervalTypeField -> r
gmapT :: (forall b. Data b => b -> b)
-> IntervalTypeField -> IntervalTypeField
$cgmapT :: (forall b. Data b => b -> b)
-> IntervalTypeField -> IntervalTypeField
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IntervalTypeField)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IntervalTypeField)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c IntervalTypeField)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IntervalTypeField)
dataTypeOf :: IntervalTypeField -> DataType
$cdataTypeOf :: IntervalTypeField -> DataType
toConstr :: IntervalTypeField -> Constr
$ctoConstr :: IntervalTypeField -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IntervalTypeField
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IntervalTypeField
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IntervalTypeField -> c IntervalTypeField
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IntervalTypeField -> c IntervalTypeField
$cp1Data :: Typeable 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
/= :: Sign -> Sign -> Bool
$c/= :: Sign -> Sign -> Bool
== :: Sign -> Sign -> Bool
$c== :: 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
showList :: [Sign] -> ShowS
$cshowList :: [Sign] -> ShowS
show :: Sign -> String
$cshow :: Sign -> String
showsPrec :: Int -> Sign -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [Sign]
$creadListPrec :: ReadPrec [Sign]
readPrec :: ReadPrec Sign
$creadPrec :: ReadPrec Sign
readList :: ReadS [Sign]
$creadList :: ReadS [Sign]
readsPrec :: Int -> ReadS Sign
$creadsPrec :: Int -> ReadS Sign
Read,Typeable Sign
DataType
Constr
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 -> DataType
Sign -> Constr
(forall b. Data b => b -> b) -> Sign -> Sign
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cMinus :: Constr
$cPlus :: Constr
$tSign :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> Sign -> m Sign
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
gmapQi :: Int -> (forall d. Data d => d -> u) -> Sign -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Sign -> u
gmapQ :: (forall d. Data d => d -> u) -> Sign -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Sign -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
gmapT :: (forall b. Data b => b -> b) -> Sign -> Sign
$cgmapT :: (forall b. Data b => b -> b) -> Sign -> Sign
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Sign)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sign)
dataTypeOf :: Sign -> DataType
$cdataTypeOf :: Sign -> DataType
toConstr :: Sign -> Constr
$ctoConstr :: Sign -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
$cp1Data :: Typeable 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
/= :: PrecMultiplier -> PrecMultiplier -> Bool
$c/= :: PrecMultiplier -> PrecMultiplier -> Bool
== :: PrecMultiplier -> PrecMultiplier -> Bool
$c== :: 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
showList :: [PrecMultiplier] -> ShowS
$cshowList :: [PrecMultiplier] -> ShowS
show :: PrecMultiplier -> String
$cshow :: PrecMultiplier -> String
showsPrec :: Int -> PrecMultiplier -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [PrecMultiplier]
$creadListPrec :: ReadPrec [PrecMultiplier]
readPrec :: ReadPrec PrecMultiplier
$creadPrec :: ReadPrec PrecMultiplier
readList :: ReadS [PrecMultiplier]
$creadList :: ReadS [PrecMultiplier]
readsPrec :: Int -> ReadS PrecMultiplier
$creadsPrec :: Int -> ReadS PrecMultiplier
Read,Typeable PrecMultiplier
DataType
Constr
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 -> DataType
PrecMultiplier -> Constr
(forall b. Data b => b -> b) -> PrecMultiplier -> PrecMultiplier
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrecMultiplier -> c PrecMultiplier
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cPrecP :: Constr
$cPrecT :: Constr
$cPrecG :: Constr
$cPrecM :: Constr
$cPrecK :: Constr
$tPrecMultiplier :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> PrecMultiplier -> m PrecMultiplier
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PrecMultiplier -> m PrecMultiplier
gmapQi :: Int -> (forall d. Data d => d -> u) -> PrecMultiplier -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PrecMultiplier -> u
gmapQ :: (forall d. Data d => d -> u) -> PrecMultiplier -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PrecMultiplier -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrecMultiplier -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrecMultiplier -> r
gmapT :: (forall b. Data b => b -> b) -> PrecMultiplier -> PrecMultiplier
$cgmapT :: (forall b. Data b => b -> b) -> PrecMultiplier -> PrecMultiplier
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrecMultiplier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrecMultiplier)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PrecMultiplier)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrecMultiplier)
dataTypeOf :: PrecMultiplier -> DataType
$cdataTypeOf :: PrecMultiplier -> DataType
toConstr :: PrecMultiplier -> Constr
$ctoConstr :: PrecMultiplier -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrecMultiplier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrecMultiplier
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrecMultiplier -> c PrecMultiplier
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrecMultiplier -> c PrecMultiplier
$cp1Data :: Typeable 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
/= :: PrecUnits -> PrecUnits -> Bool
$c/= :: PrecUnits -> PrecUnits -> Bool
== :: PrecUnits -> PrecUnits -> Bool
$c== :: 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
showList :: [PrecUnits] -> ShowS
$cshowList :: [PrecUnits] -> ShowS
show :: PrecUnits -> String
$cshow :: PrecUnits -> String
showsPrec :: Int -> PrecUnits -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [PrecUnits]
$creadListPrec :: ReadPrec [PrecUnits]
readPrec :: ReadPrec PrecUnits
$creadPrec :: ReadPrec PrecUnits
readList :: ReadS [PrecUnits]
$creadList :: ReadS [PrecUnits]
readsPrec :: Int -> ReadS PrecUnits
$creadsPrec :: Int -> ReadS PrecUnits
Read,Typeable PrecUnits
DataType
Constr
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 -> DataType
PrecUnits -> Constr
(forall b. Data b => b -> b) -> PrecUnits -> PrecUnits
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrecUnits -> c PrecUnits
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cPrecOctets :: Constr
$cPrecCharacters :: Constr
$tPrecUnits :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits
gmapQi :: Int -> (forall d. Data d => d -> u) -> PrecUnits -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PrecUnits -> u
gmapQ :: (forall d. Data d => d -> u) -> PrecUnits -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PrecUnits -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrecUnits -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrecUnits -> r
gmapT :: (forall b. Data b => b -> b) -> PrecUnits -> PrecUnits
$cgmapT :: (forall b. Data b => b -> b) -> PrecUnits -> PrecUnits
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrecUnits)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrecUnits)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PrecUnits)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrecUnits)
dataTypeOf :: PrecUnits -> DataType
$cdataTypeOf :: PrecUnits -> DataType
toConstr :: PrecUnits -> Constr
$ctoConstr :: PrecUnits -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrecUnits
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrecUnits
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrecUnits -> c PrecUnits
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrecUnits -> c PrecUnits
$cp1Data :: Typeable 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
/= :: InPredValue -> InPredValue -> Bool
$c/= :: InPredValue -> InPredValue -> Bool
== :: InPredValue -> InPredValue -> Bool
$c== :: 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
showList :: [InPredValue] -> ShowS
$cshowList :: [InPredValue] -> ShowS
show :: InPredValue -> String
$cshow :: InPredValue -> String
showsPrec :: Int -> InPredValue -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [InPredValue]
$creadListPrec :: ReadPrec [InPredValue]
readPrec :: ReadPrec InPredValue
$creadPrec :: ReadPrec InPredValue
readList :: ReadS [InPredValue]
$creadList :: ReadS [InPredValue]
readsPrec :: Int -> ReadS InPredValue
$creadsPrec :: Int -> ReadS InPredValue
Read,Typeable InPredValue
DataType
Constr
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 -> DataType
InPredValue -> Constr
(forall b. Data b => b -> b) -> InPredValue -> InPredValue
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InPredValue -> c InPredValue
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cInQueryExpr :: Constr
$cInList :: Constr
$tInPredValue :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> InPredValue -> m InPredValue
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InPredValue -> m InPredValue
gmapQi :: Int -> (forall d. Data d => d -> u) -> InPredValue -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InPredValue -> u
gmapQ :: (forall d. Data d => d -> u) -> InPredValue -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> InPredValue -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InPredValue -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InPredValue -> r
gmapT :: (forall b. Data b => b -> b) -> InPredValue -> InPredValue
$cgmapT :: (forall b. Data b => b -> b) -> InPredValue -> InPredValue
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InPredValue)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InPredValue)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c InPredValue)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InPredValue)
dataTypeOf :: InPredValue -> DataType
$cdataTypeOf :: InPredValue -> DataType
toConstr :: InPredValue -> Constr
$ctoConstr :: InPredValue -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InPredValue
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InPredValue
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InPredValue -> c InPredValue
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InPredValue -> c InPredValue
$cp1Data :: Typeable 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
/= :: SubQueryExprType -> SubQueryExprType -> Bool
$c/= :: SubQueryExprType -> SubQueryExprType -> Bool
== :: SubQueryExprType -> SubQueryExprType -> Bool
$c== :: 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
showList :: [SubQueryExprType] -> ShowS
$cshowList :: [SubQueryExprType] -> ShowS
show :: SubQueryExprType -> String
$cshow :: SubQueryExprType -> String
showsPrec :: Int -> SubQueryExprType -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [SubQueryExprType]
$creadListPrec :: ReadPrec [SubQueryExprType]
readPrec :: ReadPrec SubQueryExprType
$creadPrec :: ReadPrec SubQueryExprType
readList :: ReadS [SubQueryExprType]
$creadList :: ReadS [SubQueryExprType]
readsPrec :: Int -> ReadS SubQueryExprType
$creadsPrec :: Int -> ReadS SubQueryExprType
Read,Typeable SubQueryExprType
DataType
Constr
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 -> DataType
SubQueryExprType -> Constr
(forall b. Data b => b -> b)
-> SubQueryExprType -> SubQueryExprType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubQueryExprType -> c SubQueryExprType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cSqSq :: Constr
$cSqUnique :: Constr
$cSqExists :: Constr
$tSubQueryExprType :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> SubQueryExprType -> m SubQueryExprType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SubQueryExprType -> m SubQueryExprType
gmapQi :: Int -> (forall d. Data d => d -> u) -> SubQueryExprType -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SubQueryExprType -> u
gmapQ :: (forall d. Data d => d -> u) -> SubQueryExprType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SubQueryExprType -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubQueryExprType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubQueryExprType -> r
gmapT :: (forall b. Data b => b -> b)
-> SubQueryExprType -> SubQueryExprType
$cgmapT :: (forall b. Data b => b -> b)
-> SubQueryExprType -> SubQueryExprType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SubQueryExprType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SubQueryExprType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SubQueryExprType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SubQueryExprType)
dataTypeOf :: SubQueryExprType -> DataType
$cdataTypeOf :: SubQueryExprType -> DataType
toConstr :: SubQueryExprType -> Constr
$ctoConstr :: SubQueryExprType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubQueryExprType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubQueryExprType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubQueryExprType -> c SubQueryExprType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubQueryExprType -> c SubQueryExprType
$cp1Data :: Typeable 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
/= :: CompPredQuantifier -> CompPredQuantifier -> Bool
$c/= :: CompPredQuantifier -> CompPredQuantifier -> Bool
== :: CompPredQuantifier -> CompPredQuantifier -> Bool
$c== :: 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
showList :: [CompPredQuantifier] -> ShowS
$cshowList :: [CompPredQuantifier] -> ShowS
show :: CompPredQuantifier -> String
$cshow :: CompPredQuantifier -> String
showsPrec :: Int -> CompPredQuantifier -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [CompPredQuantifier]
$creadListPrec :: ReadPrec [CompPredQuantifier]
readPrec :: ReadPrec CompPredQuantifier
$creadPrec :: ReadPrec CompPredQuantifier
readList :: ReadS [CompPredQuantifier]
$creadList :: ReadS [CompPredQuantifier]
readsPrec :: Int -> ReadS CompPredQuantifier
$creadsPrec :: Int -> ReadS CompPredQuantifier
Read,Typeable CompPredQuantifier
DataType
Constr
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 -> DataType
CompPredQuantifier -> Constr
(forall b. Data b => b -> b)
-> CompPredQuantifier -> CompPredQuantifier
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CompPredQuantifier
-> c CompPredQuantifier
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cCPAll :: Constr
$cCPSome :: Constr
$cCPAny :: Constr
$tCompPredQuantifier :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> CompPredQuantifier -> m CompPredQuantifier
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CompPredQuantifier -> m CompPredQuantifier
gmapQi :: Int -> (forall d. Data d => d -> u) -> CompPredQuantifier -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CompPredQuantifier -> u
gmapQ :: (forall d. Data d => d -> u) -> CompPredQuantifier -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CompPredQuantifier -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompPredQuantifier -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompPredQuantifier -> r
gmapT :: (forall b. Data b => b -> b)
-> CompPredQuantifier -> CompPredQuantifier
$cgmapT :: (forall b. Data b => b -> b)
-> CompPredQuantifier -> CompPredQuantifier
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CompPredQuantifier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CompPredQuantifier)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CompPredQuantifier)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CompPredQuantifier)
dataTypeOf :: CompPredQuantifier -> DataType
$cdataTypeOf :: CompPredQuantifier -> DataType
toConstr :: CompPredQuantifier -> Constr
$ctoConstr :: CompPredQuantifier -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompPredQuantifier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompPredQuantifier
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CompPredQuantifier
-> c CompPredQuantifier
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CompPredQuantifier
-> c CompPredQuantifier
$cp1Data :: Typeable 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
/= :: SortSpec -> SortSpec -> Bool
$c/= :: SortSpec -> SortSpec -> Bool
== :: SortSpec -> SortSpec -> Bool
$c== :: 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
showList :: [SortSpec] -> ShowS
$cshowList :: [SortSpec] -> ShowS
show :: SortSpec -> String
$cshow :: SortSpec -> String
showsPrec :: Int -> SortSpec -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [SortSpec]
$creadListPrec :: ReadPrec [SortSpec]
readPrec :: ReadPrec SortSpec
$creadPrec :: ReadPrec SortSpec
readList :: ReadS [SortSpec]
$creadList :: ReadS [SortSpec]
readsPrec :: Int -> ReadS SortSpec
$creadsPrec :: Int -> ReadS SortSpec
Read,Typeable SortSpec
DataType
Constr
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 -> DataType
SortSpec -> Constr
(forall b. Data b => b -> b) -> SortSpec -> SortSpec
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SortSpec -> c SortSpec
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cSortSpec :: Constr
$tSortSpec :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> SortSpec -> m SortSpec
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SortSpec -> m SortSpec
gmapQi :: Int -> (forall d. Data d => d -> u) -> SortSpec -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SortSpec -> u
gmapQ :: (forall d. Data d => d -> u) -> SortSpec -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SortSpec -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SortSpec -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SortSpec -> r
gmapT :: (forall b. Data b => b -> b) -> SortSpec -> SortSpec
$cgmapT :: (forall b. Data b => b -> b) -> SortSpec -> SortSpec
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SortSpec)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SortSpec)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SortSpec)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SortSpec)
dataTypeOf :: SortSpec -> DataType
$cdataTypeOf :: SortSpec -> DataType
toConstr :: SortSpec -> Constr
$ctoConstr :: SortSpec -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SortSpec
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SortSpec
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SortSpec -> c SortSpec
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SortSpec -> c SortSpec
$cp1Data :: Typeable 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
/= :: NullsOrder -> NullsOrder -> Bool
$c/= :: NullsOrder -> NullsOrder -> Bool
== :: NullsOrder -> NullsOrder -> Bool
$c== :: 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
showList :: [NullsOrder] -> ShowS
$cshowList :: [NullsOrder] -> ShowS
show :: NullsOrder -> String
$cshow :: NullsOrder -> String
showsPrec :: Int -> NullsOrder -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [NullsOrder]
$creadListPrec :: ReadPrec [NullsOrder]
readPrec :: ReadPrec NullsOrder
$creadPrec :: ReadPrec NullsOrder
readList :: ReadS [NullsOrder]
$creadList :: ReadS [NullsOrder]
readsPrec :: Int -> ReadS NullsOrder
$creadsPrec :: Int -> ReadS NullsOrder
Read,Typeable NullsOrder
DataType
Constr
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 -> DataType
NullsOrder -> Constr
(forall b. Data b => b -> b) -> NullsOrder -> NullsOrder
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NullsOrder -> c NullsOrder
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cNullsLast :: Constr
$cNullsFirst :: Constr
$cNullsOrderDefault :: Constr
$tNullsOrder :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder
gmapQi :: Int -> (forall d. Data d => d -> u) -> NullsOrder -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NullsOrder -> u
gmapQ :: (forall d. Data d => d -> u) -> NullsOrder -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NullsOrder -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NullsOrder -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NullsOrder -> r
gmapT :: (forall b. Data b => b -> b) -> NullsOrder -> NullsOrder
$cgmapT :: (forall b. Data b => b -> b) -> NullsOrder -> NullsOrder
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NullsOrder)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NullsOrder)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c NullsOrder)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NullsOrder)
dataTypeOf :: NullsOrder -> DataType
$cdataTypeOf :: NullsOrder -> DataType
toConstr :: NullsOrder -> Constr
$ctoConstr :: NullsOrder -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NullsOrder
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NullsOrder
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NullsOrder -> c NullsOrder
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NullsOrder -> c NullsOrder
$cp1Data :: Typeable 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
/= :: Frame -> Frame -> Bool
$c/= :: Frame -> Frame -> Bool
== :: Frame -> Frame -> Bool
$c== :: 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
showList :: [Frame] -> ShowS
$cshowList :: [Frame] -> ShowS
show :: Frame -> String
$cshow :: Frame -> String
showsPrec :: Int -> Frame -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [Frame]
$creadListPrec :: ReadPrec [Frame]
readPrec :: ReadPrec Frame
$creadPrec :: ReadPrec Frame
readList :: ReadS [Frame]
$creadList :: ReadS [Frame]
readsPrec :: Int -> ReadS Frame
$creadsPrec :: Int -> ReadS Frame
Read,Typeable Frame
DataType
Constr
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 -> DataType
Frame -> Constr
(forall b. Data b => b -> b) -> Frame -> Frame
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Frame -> c Frame
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cFrameBetween :: Constr
$cFrameFrom :: Constr
$tFrame :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> Frame -> m Frame
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Frame -> m Frame
gmapQi :: Int -> (forall d. Data d => d -> u) -> Frame -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Frame -> u
gmapQ :: (forall d. Data d => d -> u) -> Frame -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Frame -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Frame -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Frame -> r
gmapT :: (forall b. Data b => b -> b) -> Frame -> Frame
$cgmapT :: (forall b. Data b => b -> b) -> Frame -> Frame
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Frame)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Frame)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Frame)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Frame)
dataTypeOf :: Frame -> DataType
$cdataTypeOf :: Frame -> DataType
toConstr :: Frame -> Constr
$ctoConstr :: Frame -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Frame
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Frame
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Frame -> c Frame
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Frame -> c Frame
$cp1Data :: Typeable 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
/= :: FrameRows -> FrameRows -> Bool
$c/= :: FrameRows -> FrameRows -> Bool
== :: FrameRows -> FrameRows -> Bool
$c== :: 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
showList :: [FrameRows] -> ShowS
$cshowList :: [FrameRows] -> ShowS
show :: FrameRows -> String
$cshow :: FrameRows -> String
showsPrec :: Int -> FrameRows -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [FrameRows]
$creadListPrec :: ReadPrec [FrameRows]
readPrec :: ReadPrec FrameRows
$creadPrec :: ReadPrec FrameRows
readList :: ReadS [FrameRows]
$creadList :: ReadS [FrameRows]
readsPrec :: Int -> ReadS FrameRows
$creadsPrec :: Int -> ReadS FrameRows
Read,Typeable FrameRows
DataType
Constr
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 -> DataType
FrameRows -> Constr
(forall b. Data b => b -> b) -> FrameRows -> FrameRows
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FrameRows -> c FrameRows
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cFrameRange :: Constr
$cFrameRows :: Constr
$tFrameRows :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> FrameRows -> m FrameRows
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FrameRows -> m FrameRows
gmapQi :: Int -> (forall d. Data d => d -> u) -> FrameRows -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FrameRows -> u
gmapQ :: (forall d. Data d => d -> u) -> FrameRows -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FrameRows -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FrameRows -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FrameRows -> r
gmapT :: (forall b. Data b => b -> b) -> FrameRows -> FrameRows
$cgmapT :: (forall b. Data b => b -> b) -> FrameRows -> FrameRows
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FrameRows)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FrameRows)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FrameRows)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FrameRows)
dataTypeOf :: FrameRows -> DataType
$cdataTypeOf :: FrameRows -> DataType
toConstr :: FrameRows -> Constr
$ctoConstr :: FrameRows -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FrameRows
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FrameRows
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FrameRows -> c FrameRows
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FrameRows -> c FrameRows
$cp1Data :: Typeable 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
/= :: FramePos -> FramePos -> Bool
$c/= :: FramePos -> FramePos -> Bool
== :: FramePos -> FramePos -> Bool
$c== :: 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
showList :: [FramePos] -> ShowS
$cshowList :: [FramePos] -> ShowS
show :: FramePos -> String
$cshow :: FramePos -> String
showsPrec :: Int -> FramePos -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [FramePos]
$creadListPrec :: ReadPrec [FramePos]
readPrec :: ReadPrec FramePos
$creadPrec :: ReadPrec FramePos
readList :: ReadS [FramePos]
$creadList :: ReadS [FramePos]
readsPrec :: Int -> ReadS FramePos
$creadsPrec :: Int -> ReadS FramePos
Read,Typeable FramePos
DataType
Constr
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 -> DataType
FramePos -> Constr
(forall b. Data b => b -> b) -> FramePos -> FramePos
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FramePos -> c FramePos
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cUnboundedFollowing :: Constr
$cFollowing :: Constr
$cCurrent :: Constr
$cPreceding :: Constr
$cUnboundedPreceding :: Constr
$tFramePos :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> FramePos -> m FramePos
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FramePos -> m FramePos
gmapQi :: Int -> (forall d. Data d => d -> u) -> FramePos -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FramePos -> u
gmapQ :: (forall d. Data d => d -> u) -> FramePos -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FramePos -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FramePos -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FramePos -> r
gmapT :: (forall b. Data b => b -> b) -> FramePos -> FramePos
$cgmapT :: (forall b. Data b => b -> b) -> FramePos -> FramePos
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FramePos)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FramePos)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FramePos)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FramePos)
dataTypeOf :: FramePos -> DataType
$cdataTypeOf :: FramePos -> DataType
toConstr :: FramePos -> Constr
$ctoConstr :: FramePos -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FramePos
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FramePos
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FramePos -> c FramePos
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FramePos -> c FramePos
$cp1Data :: Typeable 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
/= :: OdbcLiteralType -> OdbcLiteralType -> Bool
$c/= :: OdbcLiteralType -> OdbcLiteralType -> Bool
== :: OdbcLiteralType -> OdbcLiteralType -> Bool
$c== :: 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
showList :: [OdbcLiteralType] -> ShowS
$cshowList :: [OdbcLiteralType] -> ShowS
show :: OdbcLiteralType -> String
$cshow :: OdbcLiteralType -> String
showsPrec :: Int -> OdbcLiteralType -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [OdbcLiteralType]
$creadListPrec :: ReadPrec [OdbcLiteralType]
readPrec :: ReadPrec OdbcLiteralType
$creadPrec :: ReadPrec OdbcLiteralType
readList :: ReadS [OdbcLiteralType]
$creadList :: ReadS [OdbcLiteralType]
readsPrec :: Int -> ReadS OdbcLiteralType
$creadsPrec :: Int -> ReadS OdbcLiteralType
Read,Typeable OdbcLiteralType
DataType
Constr
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 -> DataType
OdbcLiteralType -> Constr
(forall b. Data b => b -> b) -> OdbcLiteralType -> OdbcLiteralType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OdbcLiteralType -> c OdbcLiteralType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cOLTimestamp :: Constr
$cOLTime :: Constr
$cOLDate :: Constr
$tOdbcLiteralType :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> OdbcLiteralType -> m OdbcLiteralType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> OdbcLiteralType -> m OdbcLiteralType
gmapQi :: Int -> (forall d. Data d => d -> u) -> OdbcLiteralType -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> OdbcLiteralType -> u
gmapQ :: (forall d. Data d => d -> u) -> OdbcLiteralType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OdbcLiteralType -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OdbcLiteralType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OdbcLiteralType -> r
gmapT :: (forall b. Data b => b -> b) -> OdbcLiteralType -> OdbcLiteralType
$cgmapT :: (forall b. Data b => b -> b) -> OdbcLiteralType -> OdbcLiteralType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OdbcLiteralType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OdbcLiteralType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c OdbcLiteralType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OdbcLiteralType)
dataTypeOf :: OdbcLiteralType -> DataType
$cdataTypeOf :: OdbcLiteralType -> DataType
toConstr :: OdbcLiteralType -> Constr
$ctoConstr :: OdbcLiteralType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OdbcLiteralType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OdbcLiteralType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OdbcLiteralType -> c OdbcLiteralType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OdbcLiteralType -> c OdbcLiteralType
$cp1Data :: Typeable 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
/= :: QueryExpr -> QueryExpr -> Bool
$c/= :: QueryExpr -> QueryExpr -> Bool
== :: QueryExpr -> QueryExpr -> Bool
$c== :: 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
showList :: [QueryExpr] -> ShowS
$cshowList :: [QueryExpr] -> ShowS
show :: QueryExpr -> String
$cshow :: QueryExpr -> String
showsPrec :: Int -> QueryExpr -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [QueryExpr]
$creadListPrec :: ReadPrec [QueryExpr]
readPrec :: ReadPrec QueryExpr
$creadPrec :: ReadPrec QueryExpr
readList :: ReadS [QueryExpr]
$creadList :: ReadS [QueryExpr]
readsPrec :: Int -> ReadS QueryExpr
$creadsPrec :: Int -> ReadS QueryExpr
Read,Typeable QueryExpr
DataType
Constr
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 -> DataType
QueryExpr -> Constr
(forall b. Data b => b -> b) -> QueryExpr -> QueryExpr
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QueryExpr -> c QueryExpr
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cQEComment :: Constr
$cTable :: Constr
$cValues :: Constr
$cWith :: Constr
$cQueryExprSetOp :: Constr
$cSelect :: Constr
$tQueryExpr :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr
gmapQi :: Int -> (forall d. Data d => d -> u) -> QueryExpr -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> QueryExpr -> u
gmapQ :: (forall d. Data d => d -> u) -> QueryExpr -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> QueryExpr -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QueryExpr -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QueryExpr -> r
gmapT :: (forall b. Data b => b -> b) -> QueryExpr -> QueryExpr
$cgmapT :: (forall b. Data b => b -> b) -> QueryExpr -> QueryExpr
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QueryExpr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QueryExpr)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c QueryExpr)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c QueryExpr)
dataTypeOf :: QueryExpr -> DataType
$cdataTypeOf :: QueryExpr -> DataType
toConstr :: QueryExpr -> Constr
$ctoConstr :: QueryExpr -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c QueryExpr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c QueryExpr
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QueryExpr -> c QueryExpr
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QueryExpr -> c QueryExpr
$cp1Data :: Typeable 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.

> -- | Helper/'default' value for query exprs to make creating query
> -- expr values a little easier. It is defined like this:
> --
> -- > makeSelect :: QueryExpr
> -- > makeSelect = Select {qeSetQuantifier = SQDefault
> -- >                     ,qeSelectList = []
> -- >                     ,qeFrom = []
> -- >                     ,qeWhere = Nothing
> -- >                     ,qeGroupBy = []
> -- >                     ,qeHaving = Nothing
> -- >                     ,qeOrderBy = []
> -- >                     ,qeOffset = Nothing
> -- >                     ,qeFetchFirst = Nothing}

> makeSelect :: QueryExpr
> makeSelect :: QueryExpr
makeSelect = Select :: SetQuantifier
-> [(ScalarExpr, Maybe Name)]
-> [TableRef]
-> Maybe ScalarExpr
-> [GroupingExpr]
-> Maybe ScalarExpr
-> [SortSpec]
-> Maybe ScalarExpr
-> Maybe ScalarExpr
-> QueryExpr
Select {qeSetQuantifier :: SetQuantifier
qeSetQuantifier = SetQuantifier
SQDefault
>                     ,qeSelectList :: [(ScalarExpr, Maybe Name)]
qeSelectList = []
>                     ,qeFrom :: [TableRef]
qeFrom = []
>                     ,qeWhere :: Maybe ScalarExpr
qeWhere = Maybe ScalarExpr
forall a. Maybe a
Nothing
>                     ,qeGroupBy :: [GroupingExpr]
qeGroupBy = []
>                     ,qeHaving :: Maybe ScalarExpr
qeHaving = Maybe ScalarExpr
forall a. Maybe a
Nothing
>                     ,qeOrderBy :: [SortSpec]
qeOrderBy = []
>                     ,qeOffset :: Maybe ScalarExpr
qeOffset = Maybe ScalarExpr
forall a. Maybe a
Nothing
>                     ,qeFetchFirst :: Maybe ScalarExpr
qeFetchFirst = Maybe ScalarExpr
forall a. Maybe a
Nothing}

> -- | 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
/= :: SetQuantifier -> SetQuantifier -> Bool
$c/= :: SetQuantifier -> SetQuantifier -> Bool
== :: SetQuantifier -> SetQuantifier -> Bool
$c== :: 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
showList :: [SetQuantifier] -> ShowS
$cshowList :: [SetQuantifier] -> ShowS
show :: SetQuantifier -> String
$cshow :: SetQuantifier -> String
showsPrec :: Int -> SetQuantifier -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [SetQuantifier]
$creadListPrec :: ReadPrec [SetQuantifier]
readPrec :: ReadPrec SetQuantifier
$creadPrec :: ReadPrec SetQuantifier
readList :: ReadS [SetQuantifier]
$creadList :: ReadS [SetQuantifier]
readsPrec :: Int -> ReadS SetQuantifier
$creadsPrec :: Int -> ReadS SetQuantifier
Read,Typeable SetQuantifier
DataType
Constr
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 -> DataType
SetQuantifier -> Constr
(forall b. Data b => b -> b) -> SetQuantifier -> SetQuantifier
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetQuantifier -> c SetQuantifier
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cAll :: Constr
$cDistinct :: Constr
$cSQDefault :: Constr
$tSetQuantifier :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier
gmapQi :: Int -> (forall d. Data d => d -> u) -> SetQuantifier -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SetQuantifier -> u
gmapQ :: (forall d. Data d => d -> u) -> SetQuantifier -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SetQuantifier -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SetQuantifier -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SetQuantifier -> r
gmapT :: (forall b. Data b => b -> b) -> SetQuantifier -> SetQuantifier
$cgmapT :: (forall b. Data b => b -> b) -> SetQuantifier -> SetQuantifier
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SetQuantifier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SetQuantifier)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SetQuantifier)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SetQuantifier)
dataTypeOf :: SetQuantifier -> DataType
$cdataTypeOf :: SetQuantifier -> DataType
toConstr :: SetQuantifier -> Constr
$ctoConstr :: SetQuantifier -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetQuantifier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetQuantifier
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetQuantifier -> c SetQuantifier
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetQuantifier -> c SetQuantifier
$cp1Data :: Typeable 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
/= :: Direction -> Direction -> Bool
$c/= :: Direction -> Direction -> Bool
== :: Direction -> Direction -> Bool
$c== :: 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
showList :: [Direction] -> ShowS
$cshowList :: [Direction] -> ShowS
show :: Direction -> String
$cshow :: Direction -> String
showsPrec :: Int -> Direction -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [Direction]
$creadListPrec :: ReadPrec [Direction]
readPrec :: ReadPrec Direction
$creadPrec :: ReadPrec Direction
readList :: ReadS [Direction]
$creadList :: ReadS [Direction]
readsPrec :: Int -> ReadS Direction
$creadsPrec :: Int -> ReadS Direction
Read,Typeable Direction
DataType
Constr
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 -> DataType
Direction -> Constr
(forall b. Data b => b -> b) -> Direction -> Direction
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Direction -> c Direction
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDesc :: Constr
$cAsc :: Constr
$cDirDefault :: Constr
$tDirection :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> Direction -> m Direction
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Direction -> m Direction
gmapQi :: Int -> (forall d. Data d => d -> u) -> Direction -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Direction -> u
gmapQ :: (forall d. Data d => d -> u) -> Direction -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Direction -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Direction -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Direction -> r
gmapT :: (forall b. Data b => b -> b) -> Direction -> Direction
$cgmapT :: (forall b. Data b => b -> b) -> Direction -> Direction
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Direction)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Direction)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Direction)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Direction)
dataTypeOf :: Direction -> DataType
$cdataTypeOf :: Direction -> DataType
toConstr :: Direction -> Constr
$ctoConstr :: Direction -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Direction
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Direction
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Direction -> c Direction
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Direction -> c Direction
$cp1Data :: Typeable 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
/= :: SetOperatorName -> SetOperatorName -> Bool
$c/= :: SetOperatorName -> SetOperatorName -> Bool
== :: SetOperatorName -> SetOperatorName -> Bool
$c== :: 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
showList :: [SetOperatorName] -> ShowS
$cshowList :: [SetOperatorName] -> ShowS
show :: SetOperatorName -> String
$cshow :: SetOperatorName -> String
showsPrec :: Int -> SetOperatorName -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [SetOperatorName]
$creadListPrec :: ReadPrec [SetOperatorName]
readPrec :: ReadPrec SetOperatorName
$creadPrec :: ReadPrec SetOperatorName
readList :: ReadS [SetOperatorName]
$creadList :: ReadS [SetOperatorName]
readsPrec :: Int -> ReadS SetOperatorName
$creadsPrec :: Int -> ReadS SetOperatorName
Read,Typeable SetOperatorName
DataType
Constr
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 -> DataType
SetOperatorName -> Constr
(forall b. Data b => b -> b) -> SetOperatorName -> SetOperatorName
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetOperatorName -> c SetOperatorName
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cIntersect :: Constr
$cExcept :: Constr
$cUnion :: Constr
$tSetOperatorName :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> SetOperatorName -> m SetOperatorName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SetOperatorName -> m SetOperatorName
gmapQi :: Int -> (forall d. Data d => d -> u) -> SetOperatorName -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SetOperatorName -> u
gmapQ :: (forall d. Data d => d -> u) -> SetOperatorName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SetOperatorName -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SetOperatorName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SetOperatorName -> r
gmapT :: (forall b. Data b => b -> b) -> SetOperatorName -> SetOperatorName
$cgmapT :: (forall b. Data b => b -> b) -> SetOperatorName -> SetOperatorName
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SetOperatorName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SetOperatorName)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SetOperatorName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SetOperatorName)
dataTypeOf :: SetOperatorName -> DataType
$cdataTypeOf :: SetOperatorName -> DataType
toConstr :: SetOperatorName -> Constr
$ctoConstr :: SetOperatorName -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetOperatorName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetOperatorName
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetOperatorName -> c SetOperatorName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetOperatorName -> c SetOperatorName
$cp1Data :: Typeable 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
/= :: Corresponding -> Corresponding -> Bool
$c/= :: Corresponding -> Corresponding -> Bool
== :: Corresponding -> Corresponding -> Bool
$c== :: 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
showList :: [Corresponding] -> ShowS
$cshowList :: [Corresponding] -> ShowS
show :: Corresponding -> String
$cshow :: Corresponding -> String
showsPrec :: Int -> Corresponding -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [Corresponding]
$creadListPrec :: ReadPrec [Corresponding]
readPrec :: ReadPrec Corresponding
$creadPrec :: ReadPrec Corresponding
readList :: ReadS [Corresponding]
$creadList :: ReadS [Corresponding]
readsPrec :: Int -> ReadS Corresponding
$creadsPrec :: Int -> ReadS Corresponding
Read,Typeable Corresponding
DataType
Constr
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 -> DataType
Corresponding -> Constr
(forall b. Data b => b -> b) -> Corresponding -> Corresponding
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Corresponding -> c Corresponding
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cRespectively :: Constr
$cCorresponding :: Constr
$tCorresponding :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> Corresponding -> m Corresponding
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Corresponding -> m Corresponding
gmapQi :: Int -> (forall d. Data d => d -> u) -> Corresponding -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Corresponding -> u
gmapQ :: (forall d. Data d => d -> u) -> Corresponding -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Corresponding -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Corresponding -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Corresponding -> r
gmapT :: (forall b. Data b => b -> b) -> Corresponding -> Corresponding
$cgmapT :: (forall b. Data b => b -> b) -> Corresponding -> Corresponding
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Corresponding)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Corresponding)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Corresponding)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Corresponding)
dataTypeOf :: Corresponding -> DataType
$cdataTypeOf :: Corresponding -> DataType
toConstr :: Corresponding -> Constr
$ctoConstr :: Corresponding -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Corresponding
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Corresponding
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Corresponding -> c Corresponding
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Corresponding -> c Corresponding
$cp1Data :: Typeable 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
/= :: GroupingExpr -> GroupingExpr -> Bool
$c/= :: GroupingExpr -> GroupingExpr -> Bool
== :: GroupingExpr -> GroupingExpr -> Bool
$c== :: 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
showList :: [GroupingExpr] -> ShowS
$cshowList :: [GroupingExpr] -> ShowS
show :: GroupingExpr -> String
$cshow :: GroupingExpr -> String
showsPrec :: Int -> GroupingExpr -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [GroupingExpr]
$creadListPrec :: ReadPrec [GroupingExpr]
readPrec :: ReadPrec GroupingExpr
$creadPrec :: ReadPrec GroupingExpr
readList :: ReadS [GroupingExpr]
$creadList :: ReadS [GroupingExpr]
readsPrec :: Int -> ReadS GroupingExpr
$creadsPrec :: Int -> ReadS GroupingExpr
Read,Typeable GroupingExpr
DataType
Constr
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 -> DataType
GroupingExpr -> Constr
(forall b. Data b => b -> b) -> GroupingExpr -> GroupingExpr
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GroupingExpr -> c GroupingExpr
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cSimpleGroup :: Constr
$cGroupingSets :: Constr
$cRollup :: Constr
$cCube :: Constr
$cGroupingParens :: Constr
$tGroupingExpr :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr
gmapQi :: Int -> (forall d. Data d => d -> u) -> GroupingExpr -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GroupingExpr -> u
gmapQ :: (forall d. Data d => d -> u) -> GroupingExpr -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GroupingExpr -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GroupingExpr -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GroupingExpr -> r
gmapT :: (forall b. Data b => b -> b) -> GroupingExpr -> GroupingExpr
$cgmapT :: (forall b. Data b => b -> b) -> GroupingExpr -> GroupingExpr
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GroupingExpr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GroupingExpr)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c GroupingExpr)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GroupingExpr)
dataTypeOf :: GroupingExpr -> DataType
$cdataTypeOf :: GroupingExpr -> DataType
toConstr :: GroupingExpr -> Constr
$ctoConstr :: GroupingExpr -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GroupingExpr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GroupingExpr
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GroupingExpr -> c GroupingExpr
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GroupingExpr -> c GroupingExpr
$cp1Data :: Typeable 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
/= :: TableRef -> TableRef -> Bool
$c/= :: TableRef -> TableRef -> Bool
== :: TableRef -> TableRef -> Bool
$c== :: 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
showList :: [TableRef] -> ShowS
$cshowList :: [TableRef] -> ShowS
show :: TableRef -> String
$cshow :: TableRef -> String
showsPrec :: Int -> TableRef -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [TableRef]
$creadListPrec :: ReadPrec [TableRef]
readPrec :: ReadPrec TableRef
$creadPrec :: ReadPrec TableRef
readList :: ReadS [TableRef]
$creadList :: ReadS [TableRef]
readsPrec :: Int -> ReadS TableRef
$creadsPrec :: Int -> ReadS TableRef
Read,Typeable TableRef
DataType
Constr
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 -> DataType
TableRef -> Constr
(forall b. Data b => b -> b) -> TableRef -> TableRef
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableRef -> c TableRef
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cTROdbc :: Constr
$cTRLateral :: Constr
$cTRFunction :: Constr
$cTRQueryExpr :: Constr
$cTRAlias :: Constr
$cTRParens :: Constr
$cTRJoin :: Constr
$cTRSimple :: Constr
$tTableRef :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> TableRef -> m TableRef
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TableRef -> m TableRef
gmapQi :: Int -> (forall d. Data d => d -> u) -> TableRef -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TableRef -> u
gmapQ :: (forall d. Data d => d -> u) -> TableRef -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TableRef -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TableRef -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TableRef -> r
gmapT :: (forall b. Data b => b -> b) -> TableRef -> TableRef
$cgmapT :: (forall b. Data b => b -> b) -> TableRef -> TableRef
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableRef)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableRef)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TableRef)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TableRef)
dataTypeOf :: TableRef -> DataType
$cdataTypeOf :: TableRef -> DataType
toConstr :: TableRef -> Constr
$ctoConstr :: TableRef -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TableRef
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TableRef
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableRef -> c TableRef
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableRef -> c TableRef
$cp1Data :: Typeable 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
/= :: Alias -> Alias -> Bool
$c/= :: Alias -> Alias -> Bool
== :: Alias -> Alias -> Bool
$c== :: 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
showList :: [Alias] -> ShowS
$cshowList :: [Alias] -> ShowS
show :: Alias -> String
$cshow :: Alias -> String
showsPrec :: Int -> Alias -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [Alias]
$creadListPrec :: ReadPrec [Alias]
readPrec :: ReadPrec Alias
$creadPrec :: ReadPrec Alias
readList :: ReadS [Alias]
$creadList :: ReadS [Alias]
readsPrec :: Int -> ReadS Alias
$creadsPrec :: Int -> ReadS Alias
Read,Typeable Alias
DataType
Constr
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 -> DataType
Alias -> Constr
(forall b. Data b => b -> b) -> Alias -> Alias
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alias -> c Alias
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cAlias :: Constr
$tAlias :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> Alias -> m Alias
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Alias -> m Alias
gmapQi :: Int -> (forall d. Data d => d -> u) -> Alias -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Alias -> u
gmapQ :: (forall d. Data d => d -> u) -> Alias -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Alias -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alias -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alias -> r
gmapT :: (forall b. Data b => b -> b) -> Alias -> Alias
$cgmapT :: (forall b. Data b => b -> b) -> Alias -> Alias
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alias)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alias)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Alias)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Alias)
dataTypeOf :: Alias -> DataType
$cdataTypeOf :: Alias -> DataType
toConstr :: Alias -> Constr
$ctoConstr :: Alias -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Alias
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Alias
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alias -> c Alias
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alias -> c Alias
$cp1Data :: Typeable 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
/= :: JoinType -> JoinType -> Bool
$c/= :: JoinType -> JoinType -> Bool
== :: JoinType -> JoinType -> Bool
$c== :: 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
showList :: [JoinType] -> ShowS
$cshowList :: [JoinType] -> ShowS
show :: JoinType -> String
$cshow :: JoinType -> String
showsPrec :: Int -> JoinType -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [JoinType]
$creadListPrec :: ReadPrec [JoinType]
readPrec :: ReadPrec JoinType
$creadPrec :: ReadPrec JoinType
readList :: ReadS [JoinType]
$creadList :: ReadS [JoinType]
readsPrec :: Int -> ReadS JoinType
$creadsPrec :: Int -> ReadS JoinType
Read,Typeable JoinType
DataType
Constr
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 -> DataType
JoinType -> Constr
(forall b. Data b => b -> b) -> JoinType -> JoinType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoinType -> c JoinType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cJCross :: Constr
$cJFull :: Constr
$cJRight :: Constr
$cJLeft :: Constr
$cJInner :: Constr
$tJoinType :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> JoinType -> m JoinType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> JoinType -> m JoinType
gmapQi :: Int -> (forall d. Data d => d -> u) -> JoinType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> JoinType -> u
gmapQ :: (forall d. Data d => d -> u) -> JoinType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> JoinType -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoinType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoinType -> r
gmapT :: (forall b. Data b => b -> b) -> JoinType -> JoinType
$cgmapT :: (forall b. Data b => b -> b) -> JoinType -> JoinType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c JoinType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JoinType)
dataTypeOf :: JoinType -> DataType
$cdataTypeOf :: JoinType -> DataType
toConstr :: JoinType -> Constr
$ctoConstr :: JoinType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoinType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoinType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoinType -> c JoinType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoinType -> c JoinType
$cp1Data :: Typeable 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
/= :: JoinCondition -> JoinCondition -> Bool
$c/= :: JoinCondition -> JoinCondition -> Bool
== :: JoinCondition -> JoinCondition -> Bool
$c== :: 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
showList :: [JoinCondition] -> ShowS
$cshowList :: [JoinCondition] -> ShowS
show :: JoinCondition -> String
$cshow :: JoinCondition -> String
showsPrec :: Int -> JoinCondition -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [JoinCondition]
$creadListPrec :: ReadPrec [JoinCondition]
readPrec :: ReadPrec JoinCondition
$creadPrec :: ReadPrec JoinCondition
readList :: ReadS [JoinCondition]
$creadList :: ReadS [JoinCondition]
readsPrec :: Int -> ReadS JoinCondition
$creadsPrec :: Int -> ReadS JoinCondition
Read,Typeable JoinCondition
DataType
Constr
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 -> DataType
JoinCondition -> Constr
(forall b. Data b => b -> b) -> JoinCondition -> JoinCondition
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoinCondition -> c JoinCondition
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cJoinUsing :: Constr
$cJoinOn :: Constr
$tJoinCondition :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition
gmapQi :: Int -> (forall d. Data d => d -> u) -> JoinCondition -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> JoinCondition -> u
gmapQ :: (forall d. Data d => d -> u) -> JoinCondition -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> JoinCondition -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoinCondition -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoinCondition -> r
gmapT :: (forall b. Data b => b -> b) -> JoinCondition -> JoinCondition
$cgmapT :: (forall b. Data b => b -> b) -> JoinCondition -> JoinCondition
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c JoinCondition)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c JoinCondition)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c JoinCondition)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JoinCondition)
dataTypeOf :: JoinCondition -> DataType
$cdataTypeOf :: JoinCondition -> DataType
toConstr :: JoinCondition -> Constr
$ctoConstr :: JoinCondition -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoinCondition
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoinCondition
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoinCondition -> c JoinCondition
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoinCondition -> c JoinCondition
$cp1Data :: Typeable JoinCondition
Data,Typeable)

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

> data Statement =
>     -- ddl
>     CreateSchema [Name]
>   | DropSchema [Name] DropBehaviour
>   | CreateTable [Name] [TableElement]
>   | AlterTable [Name] AlterTableAction
>   | DropTable [Name] DropBehaviour
>   | 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]
>     deriving (Statement -> Statement -> Bool
(Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool) -> Eq Statement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Statement -> Statement -> Bool
$c/= :: Statement -> Statement -> Bool
== :: Statement -> Statement -> Bool
$c== :: 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
showList :: [Statement] -> ShowS
$cshowList :: [Statement] -> ShowS
show :: Statement -> String
$cshow :: Statement -> String
showsPrec :: Int -> Statement -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [Statement]
$creadListPrec :: ReadPrec [Statement]
readPrec :: ReadPrec Statement
$creadPrec :: ReadPrec Statement
readList :: ReadS [Statement]
$creadList :: ReadS [Statement]
readsPrec :: Int -> ReadS Statement
$creadsPrec :: Int -> ReadS Statement
Read,Typeable Statement
DataType
Constr
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 -> DataType
Statement -> Constr
(forall b. Data b => b -> b) -> Statement -> Statement
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cStatementComment :: Constr
$cRollback :: Constr
$cCommit :: Constr
$cReleaseSavepoint :: Constr
$cSavepoint :: Constr
$cStartTransaction :: Constr
$cRevokeRole :: Constr
$cRevokePrivilege :: Constr
$cDropRole :: Constr
$cCreateRole :: Constr
$cGrantRole :: Constr
$cGrantPrivilege :: Constr
$cUpdate :: Constr
$cInsert :: Constr
$cTruncate :: Constr
$cDelete :: Constr
$cSelectStatement :: Constr
$cDropSequence :: Constr
$cAlterSequence :: Constr
$cCreateSequence :: Constr
$cDropAssertion :: Constr
$cCreateAssertion :: Constr
$cDropDomain :: Constr
$cAlterDomain :: Constr
$cCreateDomain :: Constr
$cDropView :: Constr
$cCreateView :: Constr
$cDropTable :: Constr
$cAlterTable :: Constr
$cCreateTable :: Constr
$cDropSchema :: Constr
$cCreateSchema :: Constr
$tStatement :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> Statement -> m Statement
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
gmapQi :: Int -> (forall d. Data d => d -> u) -> Statement -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Statement -> u
gmapQ :: (forall d. Data d => d -> u) -> Statement -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Statement -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
gmapT :: (forall b. Data b => b -> b) -> Statement -> Statement
$cgmapT :: (forall b. Data b => b -> b) -> Statement -> Statement
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Statement)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Statement)
dataTypeOf :: Statement -> DataType
$cdataTypeOf :: Statement -> DataType
toConstr :: Statement -> Constr
$ctoConstr :: Statement -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
$cp1Data :: Typeable 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
/= :: DropBehaviour -> DropBehaviour -> Bool
$c/= :: DropBehaviour -> DropBehaviour -> Bool
== :: DropBehaviour -> DropBehaviour -> Bool
$c== :: 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
showList :: [DropBehaviour] -> ShowS
$cshowList :: [DropBehaviour] -> ShowS
show :: DropBehaviour -> String
$cshow :: DropBehaviour -> String
showsPrec :: Int -> DropBehaviour -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [DropBehaviour]
$creadListPrec :: ReadPrec [DropBehaviour]
readPrec :: ReadPrec DropBehaviour
$creadPrec :: ReadPrec DropBehaviour
readList :: ReadS [DropBehaviour]
$creadList :: ReadS [DropBehaviour]
readsPrec :: Int -> ReadS DropBehaviour
$creadsPrec :: Int -> ReadS DropBehaviour
Read,Typeable DropBehaviour
DataType
Constr
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 -> DataType
DropBehaviour -> Constr
(forall b. Data b => b -> b) -> DropBehaviour -> DropBehaviour
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DropBehaviour -> c DropBehaviour
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDefaultDropBehaviour :: Constr
$cCascade :: Constr
$cRestrict :: Constr
$tDropBehaviour :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> DropBehaviour -> m DropBehaviour
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DropBehaviour -> m DropBehaviour
gmapQi :: Int -> (forall d. Data d => d -> u) -> DropBehaviour -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DropBehaviour -> u
gmapQ :: (forall d. Data d => d -> u) -> DropBehaviour -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DropBehaviour -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DropBehaviour -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DropBehaviour -> r
gmapT :: (forall b. Data b => b -> b) -> DropBehaviour -> DropBehaviour
$cgmapT :: (forall b. Data b => b -> b) -> DropBehaviour -> DropBehaviour
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DropBehaviour)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DropBehaviour)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DropBehaviour)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DropBehaviour)
dataTypeOf :: DropBehaviour -> DataType
$cdataTypeOf :: DropBehaviour -> DataType
toConstr :: DropBehaviour -> Constr
$ctoConstr :: DropBehaviour -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DropBehaviour
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DropBehaviour
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DropBehaviour -> c DropBehaviour
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DropBehaviour -> c DropBehaviour
$cp1Data :: Typeable 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
/= :: IdentityRestart -> IdentityRestart -> Bool
$c/= :: IdentityRestart -> IdentityRestart -> Bool
== :: IdentityRestart -> IdentityRestart -> Bool
$c== :: 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
showList :: [IdentityRestart] -> ShowS
$cshowList :: [IdentityRestart] -> ShowS
show :: IdentityRestart -> String
$cshow :: IdentityRestart -> String
showsPrec :: Int -> IdentityRestart -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [IdentityRestart]
$creadListPrec :: ReadPrec [IdentityRestart]
readPrec :: ReadPrec IdentityRestart
$creadPrec :: ReadPrec IdentityRestart
readList :: ReadS [IdentityRestart]
$creadList :: ReadS [IdentityRestart]
readsPrec :: Int -> ReadS IdentityRestart
$creadsPrec :: Int -> ReadS IdentityRestart
Read,Typeable IdentityRestart
DataType
Constr
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 -> DataType
IdentityRestart -> Constr
(forall b. Data b => b -> b) -> IdentityRestart -> IdentityRestart
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IdentityRestart -> c IdentityRestart
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDefaultIdentityRestart :: Constr
$cRestartIdentity :: Constr
$cContinueIdentity :: Constr
$tIdentityRestart :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> IdentityRestart -> m IdentityRestart
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> IdentityRestart -> m IdentityRestart
gmapQi :: Int -> (forall d. Data d => d -> u) -> IdentityRestart -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> IdentityRestart -> u
gmapQ :: (forall d. Data d => d -> u) -> IdentityRestart -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IdentityRestart -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IdentityRestart -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IdentityRestart -> r
gmapT :: (forall b. Data b => b -> b) -> IdentityRestart -> IdentityRestart
$cgmapT :: (forall b. Data b => b -> b) -> IdentityRestart -> IdentityRestart
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IdentityRestart)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IdentityRestart)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c IdentityRestart)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IdentityRestart)
dataTypeOf :: IdentityRestart -> DataType
$cdataTypeOf :: IdentityRestart -> DataType
toConstr :: IdentityRestart -> Constr
$ctoConstr :: IdentityRestart -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IdentityRestart
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IdentityRestart
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IdentityRestart -> c IdentityRestart
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IdentityRestart -> c IdentityRestart
$cp1Data :: Typeable 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
/= :: InsertSource -> InsertSource -> Bool
$c/= :: InsertSource -> InsertSource -> Bool
== :: InsertSource -> InsertSource -> Bool
$c== :: 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
showList :: [InsertSource] -> ShowS
$cshowList :: [InsertSource] -> ShowS
show :: InsertSource -> String
$cshow :: InsertSource -> String
showsPrec :: Int -> InsertSource -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [InsertSource]
$creadListPrec :: ReadPrec [InsertSource]
readPrec :: ReadPrec InsertSource
$creadPrec :: ReadPrec InsertSource
readList :: ReadS [InsertSource]
$creadList :: ReadS [InsertSource]
readsPrec :: Int -> ReadS InsertSource
$creadsPrec :: Int -> ReadS InsertSource
Read,Typeable InsertSource
DataType
Constr
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 -> DataType
InsertSource -> Constr
(forall b. Data b => b -> b) -> InsertSource -> InsertSource
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InsertSource -> c InsertSource
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDefaultInsertValues :: Constr
$cInsertQuery :: Constr
$tInsertSource :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> InsertSource -> m InsertSource
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InsertSource -> m InsertSource
gmapQi :: Int -> (forall d. Data d => d -> u) -> InsertSource -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InsertSource -> u
gmapQ :: (forall d. Data d => d -> u) -> InsertSource -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> InsertSource -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InsertSource -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InsertSource -> r
gmapT :: (forall b. Data b => b -> b) -> InsertSource -> InsertSource
$cgmapT :: (forall b. Data b => b -> b) -> InsertSource -> InsertSource
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InsertSource)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InsertSource)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c InsertSource)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InsertSource)
dataTypeOf :: InsertSource -> DataType
$cdataTypeOf :: InsertSource -> DataType
toConstr :: InsertSource -> Constr
$ctoConstr :: InsertSource -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InsertSource
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InsertSource
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InsertSource -> c InsertSource
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InsertSource -> c InsertSource
$cp1Data :: Typeable 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
/= :: SetClause -> SetClause -> Bool
$c/= :: SetClause -> SetClause -> Bool
== :: SetClause -> SetClause -> Bool
$c== :: 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
showList :: [SetClause] -> ShowS
$cshowList :: [SetClause] -> ShowS
show :: SetClause -> String
$cshow :: SetClause -> String
showsPrec :: Int -> SetClause -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [SetClause]
$creadListPrec :: ReadPrec [SetClause]
readPrec :: ReadPrec SetClause
$creadPrec :: ReadPrec SetClause
readList :: ReadS [SetClause]
$creadList :: ReadS [SetClause]
readsPrec :: Int -> ReadS SetClause
$creadsPrec :: Int -> ReadS SetClause
Read,Typeable SetClause
DataType
Constr
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 -> DataType
SetClause -> Constr
(forall b. Data b => b -> b) -> SetClause -> SetClause
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetClause -> c SetClause
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cSetMultiple :: Constr
$cSet :: Constr
$tSetClause :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> SetClause -> m SetClause
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SetClause -> m SetClause
gmapQi :: Int -> (forall d. Data d => d -> u) -> SetClause -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SetClause -> u
gmapQ :: (forall d. Data d => d -> u) -> SetClause -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SetClause -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SetClause -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SetClause -> r
gmapT :: (forall b. Data b => b -> b) -> SetClause -> SetClause
$cgmapT :: (forall b. Data b => b -> b) -> SetClause -> SetClause
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SetClause)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SetClause)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SetClause)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SetClause)
dataTypeOf :: SetClause -> DataType
$cdataTypeOf :: SetClause -> DataType
toConstr :: SetClause -> Constr
$ctoConstr :: SetClause -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetClause
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SetClause
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetClause -> c SetClause
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SetClause -> c SetClause
$cp1Data :: Typeable 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
/= :: TableElement -> TableElement -> Bool
$c/= :: TableElement -> TableElement -> Bool
== :: TableElement -> TableElement -> Bool
$c== :: 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
showList :: [TableElement] -> ShowS
$cshowList :: [TableElement] -> ShowS
show :: TableElement -> String
$cshow :: TableElement -> String
showsPrec :: Int -> TableElement -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [TableElement]
$creadListPrec :: ReadPrec [TableElement]
readPrec :: ReadPrec TableElement
$creadPrec :: ReadPrec TableElement
readList :: ReadS [TableElement]
$creadList :: ReadS [TableElement]
readsPrec :: Int -> ReadS TableElement
$creadsPrec :: Int -> ReadS TableElement
Read,Typeable TableElement
DataType
Constr
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 -> DataType
TableElement -> Constr
(forall b. Data b => b -> b) -> TableElement -> TableElement
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableElement -> c TableElement
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cTableConstraintDef :: Constr
$cTableColumnDef :: Constr
$tTableElement :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> TableElement -> m TableElement
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TableElement -> m TableElement
gmapQi :: Int -> (forall d. Data d => d -> u) -> TableElement -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TableElement -> u
gmapQ :: (forall d. Data d => d -> u) -> TableElement -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TableElement -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TableElement -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TableElement -> r
gmapT :: (forall b. Data b => b -> b) -> TableElement -> TableElement
$cgmapT :: (forall b. Data b => b -> b) -> TableElement -> TableElement
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TableElement)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TableElement)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TableElement)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TableElement)
dataTypeOf :: TableElement -> DataType
$cdataTypeOf :: TableElement -> DataType
toConstr :: TableElement -> Constr
$ctoConstr :: TableElement -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TableElement
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TableElement
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableElement -> c TableElement
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableElement -> c TableElement
$cp1Data :: Typeable 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
/= :: ColumnDef -> ColumnDef -> Bool
$c/= :: ColumnDef -> ColumnDef -> Bool
== :: ColumnDef -> ColumnDef -> Bool
$c== :: 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
showList :: [ColumnDef] -> ShowS
$cshowList :: [ColumnDef] -> ShowS
show :: ColumnDef -> String
$cshow :: ColumnDef -> String
showsPrec :: Int -> ColumnDef -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [ColumnDef]
$creadListPrec :: ReadPrec [ColumnDef]
readPrec :: ReadPrec ColumnDef
$creadPrec :: ReadPrec ColumnDef
readList :: ReadS [ColumnDef]
$creadList :: ReadS [ColumnDef]
readsPrec :: Int -> ReadS ColumnDef
$creadsPrec :: Int -> ReadS ColumnDef
Read,Typeable ColumnDef
DataType
Constr
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 -> DataType
ColumnDef -> Constr
(forall b. Data b => b -> b) -> ColumnDef -> ColumnDef
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColumnDef -> c ColumnDef
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cColumnDef :: Constr
$tColumnDef :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> ColumnDef -> m ColumnDef
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ColumnDef -> m ColumnDef
gmapQi :: Int -> (forall d. Data d => d -> u) -> ColumnDef -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ColumnDef -> u
gmapQ :: (forall d. Data d => d -> u) -> ColumnDef -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ColumnDef -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnDef -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnDef -> r
gmapT :: (forall b. Data b => b -> b) -> ColumnDef -> ColumnDef
$cgmapT :: (forall b. Data b => b -> b) -> ColumnDef -> ColumnDef
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColumnDef)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColumnDef)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ColumnDef)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ColumnDef)
dataTypeOf :: ColumnDef -> DataType
$cdataTypeOf :: ColumnDef -> DataType
toConstr :: ColumnDef -> Constr
$ctoConstr :: ColumnDef -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColumnDef
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColumnDef
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColumnDef -> c ColumnDef
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColumnDef -> c ColumnDef
$cp1Data :: Typeable 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
/= :: ColConstraintDef -> ColConstraintDef -> Bool
$c/= :: ColConstraintDef -> ColConstraintDef -> Bool
== :: ColConstraintDef -> ColConstraintDef -> Bool
$c== :: 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
showList :: [ColConstraintDef] -> ShowS
$cshowList :: [ColConstraintDef] -> ShowS
show :: ColConstraintDef -> String
$cshow :: ColConstraintDef -> String
showsPrec :: Int -> ColConstraintDef -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [ColConstraintDef]
$creadListPrec :: ReadPrec [ColConstraintDef]
readPrec :: ReadPrec ColConstraintDef
$creadPrec :: ReadPrec ColConstraintDef
readList :: ReadS [ColConstraintDef]
$creadList :: ReadS [ColConstraintDef]
readsPrec :: Int -> ReadS ColConstraintDef
$creadsPrec :: Int -> ReadS ColConstraintDef
Read,Typeable ColConstraintDef
DataType
Constr
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 -> DataType
ColConstraintDef -> Constr
(forall b. Data b => b -> b)
-> ColConstraintDef -> ColConstraintDef
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColConstraintDef -> c ColConstraintDef
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cColConstraintDef :: Constr
$tColConstraintDef :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> ColConstraintDef -> m ColConstraintDef
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ColConstraintDef -> m ColConstraintDef
gmapQi :: Int -> (forall d. Data d => d -> u) -> ColConstraintDef -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ColConstraintDef -> u
gmapQ :: (forall d. Data d => d -> u) -> ColConstraintDef -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ColConstraintDef -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColConstraintDef -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColConstraintDef -> r
gmapT :: (forall b. Data b => b -> b)
-> ColConstraintDef -> ColConstraintDef
$cgmapT :: (forall b. Data b => b -> b)
-> ColConstraintDef -> ColConstraintDef
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ColConstraintDef)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ColConstraintDef)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ColConstraintDef)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ColConstraintDef)
dataTypeOf :: ColConstraintDef -> DataType
$cdataTypeOf :: ColConstraintDef -> DataType
toConstr :: ColConstraintDef -> Constr
$ctoConstr :: ColConstraintDef -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColConstraintDef
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColConstraintDef
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColConstraintDef -> c ColConstraintDef
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColConstraintDef -> c ColConstraintDef
$cp1Data :: Typeable ColConstraintDef
Data,Typeable)

> data ColConstraint =
>     ColNotNullConstraint
>   | ColUniqueConstraint
>   | ColPrimaryKeyConstraint
>   | 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
/= :: ColConstraint -> ColConstraint -> Bool
$c/= :: ColConstraint -> ColConstraint -> Bool
== :: ColConstraint -> ColConstraint -> Bool
$c== :: 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
showList :: [ColConstraint] -> ShowS
$cshowList :: [ColConstraint] -> ShowS
show :: ColConstraint -> String
$cshow :: ColConstraint -> String
showsPrec :: Int -> ColConstraint -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [ColConstraint]
$creadListPrec :: ReadPrec [ColConstraint]
readPrec :: ReadPrec ColConstraint
$creadPrec :: ReadPrec ColConstraint
readList :: ReadS [ColConstraint]
$creadList :: ReadS [ColConstraint]
readsPrec :: Int -> ReadS ColConstraint
$creadsPrec :: Int -> ReadS ColConstraint
Read,Typeable ColConstraint
DataType
Constr
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 -> DataType
ColConstraint -> Constr
(forall b. Data b => b -> b) -> ColConstraint -> ColConstraint
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColConstraint -> c ColConstraint
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cColCheckConstraint :: Constr
$cColReferencesConstraint :: Constr
$cColPrimaryKeyConstraint :: Constr
$cColUniqueConstraint :: Constr
$cColNotNullConstraint :: Constr
$tColConstraint :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> ColConstraint -> m ColConstraint
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ColConstraint -> m ColConstraint
gmapQi :: Int -> (forall d. Data d => d -> u) -> ColConstraint -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ColConstraint -> u
gmapQ :: (forall d. Data d => d -> u) -> ColConstraint -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ColConstraint -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColConstraint -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColConstraint -> r
gmapT :: (forall b. Data b => b -> b) -> ColConstraint -> ColConstraint
$cgmapT :: (forall b. Data b => b -> b) -> ColConstraint -> ColConstraint
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ColConstraint)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ColConstraint)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ColConstraint)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ColConstraint)
dataTypeOf :: ColConstraint -> DataType
$cdataTypeOf :: ColConstraint -> DataType
toConstr :: ColConstraint -> Constr
$ctoConstr :: ColConstraint -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColConstraint
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColConstraint
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColConstraint -> c ColConstraint
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColConstraint -> c ColConstraint
$cp1Data :: Typeable 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
/= :: TableConstraint -> TableConstraint -> Bool
$c/= :: TableConstraint -> TableConstraint -> Bool
== :: TableConstraint -> TableConstraint -> Bool
$c== :: 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
showList :: [TableConstraint] -> ShowS
$cshowList :: [TableConstraint] -> ShowS
show :: TableConstraint -> String
$cshow :: TableConstraint -> String
showsPrec :: Int -> TableConstraint -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [TableConstraint]
$creadListPrec :: ReadPrec [TableConstraint]
readPrec :: ReadPrec TableConstraint
$creadPrec :: ReadPrec TableConstraint
readList :: ReadS [TableConstraint]
$creadList :: ReadS [TableConstraint]
readsPrec :: Int -> ReadS TableConstraint
$creadsPrec :: Int -> ReadS TableConstraint
Read,Typeable TableConstraint
DataType
Constr
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 -> DataType
TableConstraint -> Constr
(forall b. Data b => b -> b) -> TableConstraint -> TableConstraint
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableConstraint -> c TableConstraint
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cTableCheckConstraint :: Constr
$cTableReferencesConstraint :: Constr
$cTablePrimaryKeyConstraint :: Constr
$cTableUniqueConstraint :: Constr
$tTableConstraint :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> TableConstraint -> m TableConstraint
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TableConstraint -> m TableConstraint
gmapQi :: Int -> (forall d. Data d => d -> u) -> TableConstraint -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TableConstraint -> u
gmapQ :: (forall d. Data d => d -> u) -> TableConstraint -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TableConstraint -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TableConstraint -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TableConstraint -> r
gmapT :: (forall b. Data b => b -> b) -> TableConstraint -> TableConstraint
$cgmapT :: (forall b. Data b => b -> b) -> TableConstraint -> TableConstraint
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TableConstraint)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TableConstraint)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TableConstraint)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TableConstraint)
dataTypeOf :: TableConstraint -> DataType
$cdataTypeOf :: TableConstraint -> DataType
toConstr :: TableConstraint -> Constr
$ctoConstr :: TableConstraint -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TableConstraint
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TableConstraint
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableConstraint -> c TableConstraint
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TableConstraint -> c TableConstraint
$cp1Data :: Typeable 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
/= :: ReferenceMatch -> ReferenceMatch -> Bool
$c/= :: ReferenceMatch -> ReferenceMatch -> Bool
== :: ReferenceMatch -> ReferenceMatch -> Bool
$c== :: 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
showList :: [ReferenceMatch] -> ShowS
$cshowList :: [ReferenceMatch] -> ShowS
show :: ReferenceMatch -> String
$cshow :: ReferenceMatch -> String
showsPrec :: Int -> ReferenceMatch -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [ReferenceMatch]
$creadListPrec :: ReadPrec [ReferenceMatch]
readPrec :: ReadPrec ReferenceMatch
$creadPrec :: ReadPrec ReferenceMatch
readList :: ReadS [ReferenceMatch]
$creadList :: ReadS [ReferenceMatch]
readsPrec :: Int -> ReadS ReferenceMatch
$creadsPrec :: Int -> ReadS ReferenceMatch
Read,Typeable ReferenceMatch
DataType
Constr
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 -> DataType
ReferenceMatch -> Constr
(forall b. Data b => b -> b) -> ReferenceMatch -> ReferenceMatch
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ReferenceMatch -> c ReferenceMatch
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cMatchSimple :: Constr
$cMatchPartial :: Constr
$cMatchFull :: Constr
$cDefaultReferenceMatch :: Constr
$tReferenceMatch :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> ReferenceMatch -> m ReferenceMatch
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ReferenceMatch -> m ReferenceMatch
gmapQi :: Int -> (forall d. Data d => d -> u) -> ReferenceMatch -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ReferenceMatch -> u
gmapQ :: (forall d. Data d => d -> u) -> ReferenceMatch -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ReferenceMatch -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ReferenceMatch -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ReferenceMatch -> r
gmapT :: (forall b. Data b => b -> b) -> ReferenceMatch -> ReferenceMatch
$cgmapT :: (forall b. Data b => b -> b) -> ReferenceMatch -> ReferenceMatch
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ReferenceMatch)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ReferenceMatch)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ReferenceMatch)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ReferenceMatch)
dataTypeOf :: ReferenceMatch -> DataType
$cdataTypeOf :: ReferenceMatch -> DataType
toConstr :: ReferenceMatch -> Constr
$ctoConstr :: ReferenceMatch -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ReferenceMatch
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ReferenceMatch
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ReferenceMatch -> c ReferenceMatch
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ReferenceMatch -> c ReferenceMatch
$cp1Data :: Typeable 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
/= :: ReferentialAction -> ReferentialAction -> Bool
$c/= :: ReferentialAction -> ReferentialAction -> Bool
== :: ReferentialAction -> ReferentialAction -> Bool
$c== :: 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
showList :: [ReferentialAction] -> ShowS
$cshowList :: [ReferentialAction] -> ShowS
show :: ReferentialAction -> String
$cshow :: ReferentialAction -> String
showsPrec :: Int -> ReferentialAction -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [ReferentialAction]
$creadListPrec :: ReadPrec [ReferentialAction]
readPrec :: ReadPrec ReferentialAction
$creadPrec :: ReadPrec ReferentialAction
readList :: ReadS [ReferentialAction]
$creadList :: ReadS [ReferentialAction]
readsPrec :: Int -> ReadS ReferentialAction
$creadsPrec :: Int -> ReadS ReferentialAction
Read,Typeable ReferentialAction
DataType
Constr
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 -> DataType
ReferentialAction -> Constr
(forall b. Data b => b -> b)
-> ReferentialAction -> ReferentialAction
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ReferentialAction -> c ReferentialAction
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cRefNoAction :: Constr
$cRefRestrict :: Constr
$cRefSetDefault :: Constr
$cRefSetNull :: Constr
$cRefCascade :: Constr
$cDefaultReferentialAction :: Constr
$tReferentialAction :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> ReferentialAction -> m ReferentialAction
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ReferentialAction -> m ReferentialAction
gmapQi :: Int -> (forall d. Data d => d -> u) -> ReferentialAction -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ReferentialAction -> u
gmapQ :: (forall d. Data d => d -> u) -> ReferentialAction -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ReferentialAction -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ReferentialAction -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ReferentialAction -> r
gmapT :: (forall b. Data b => b -> b)
-> ReferentialAction -> ReferentialAction
$cgmapT :: (forall b. Data b => b -> b)
-> ReferentialAction -> ReferentialAction
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ReferentialAction)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ReferentialAction)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ReferentialAction)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ReferentialAction)
dataTypeOf :: ReferentialAction -> DataType
$cdataTypeOf :: ReferentialAction -> DataType
toConstr :: ReferentialAction -> Constr
$ctoConstr :: ReferentialAction -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ReferentialAction
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ReferentialAction
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ReferentialAction -> c ReferentialAction
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ReferentialAction -> c ReferentialAction
$cp1Data :: Typeable 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
/= :: AlterTableAction -> AlterTableAction -> Bool
$c/= :: AlterTableAction -> AlterTableAction -> Bool
== :: AlterTableAction -> AlterTableAction -> Bool
$c== :: 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
showList :: [AlterTableAction] -> ShowS
$cshowList :: [AlterTableAction] -> ShowS
show :: AlterTableAction -> String
$cshow :: AlterTableAction -> String
showsPrec :: Int -> AlterTableAction -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [AlterTableAction]
$creadListPrec :: ReadPrec [AlterTableAction]
readPrec :: ReadPrec AlterTableAction
$creadPrec :: ReadPrec AlterTableAction
readList :: ReadS [AlterTableAction]
$creadList :: ReadS [AlterTableAction]
readsPrec :: Int -> ReadS AlterTableAction
$creadsPrec :: Int -> ReadS AlterTableAction
Read,Typeable AlterTableAction
DataType
Constr
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 -> DataType
AlterTableAction -> Constr
(forall b. Data b => b -> b)
-> AlterTableAction -> AlterTableAction
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlterTableAction -> c AlterTableAction
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cDropTableConstraintDef :: Constr
$cAddTableConstraintDef :: Constr
$cDropColumn :: Constr
$cAlterColumnSetDataType :: Constr
$cAlterColumnDropNotNull :: Constr
$cAlterColumnSetNotNull :: Constr
$cAlterColumnDropDefault :: Constr
$cAlterColumnSetDefault :: Constr
$cAddColumnDef :: Constr
$tAlterTableAction :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> AlterTableAction -> m AlterTableAction
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AlterTableAction -> m AlterTableAction
gmapQi :: Int -> (forall d. Data d => d -> u) -> AlterTableAction -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> AlterTableAction -> u
gmapQ :: (forall d. Data d => d -> u) -> AlterTableAction -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AlterTableAction -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlterTableAction -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlterTableAction -> r
gmapT :: (forall b. Data b => b -> b)
-> AlterTableAction -> AlterTableAction
$cgmapT :: (forall b. Data b => b -> b)
-> AlterTableAction -> AlterTableAction
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AlterTableAction)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AlterTableAction)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c AlterTableAction)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlterTableAction)
dataTypeOf :: AlterTableAction -> DataType
$cdataTypeOf :: AlterTableAction -> DataType
toConstr :: AlterTableAction -> Constr
$ctoConstr :: AlterTableAction -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlterTableAction
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlterTableAction
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlterTableAction -> c AlterTableAction
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlterTableAction -> c AlterTableAction
$cp1Data :: Typeable 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
/= :: DefaultClause -> DefaultClause -> Bool
$c/= :: DefaultClause -> DefaultClause -> Bool
== :: DefaultClause -> DefaultClause -> Bool
$c== :: 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
showList :: [DefaultClause] -> ShowS
$cshowList :: [DefaultClause] -> ShowS
show :: DefaultClause -> String
$cshow :: DefaultClause -> String
showsPrec :: Int -> DefaultClause -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [DefaultClause]
$creadListPrec :: ReadPrec [DefaultClause]
readPrec :: ReadPrec DefaultClause
$creadPrec :: ReadPrec DefaultClause
readList :: ReadS [DefaultClause]
$creadList :: ReadS [DefaultClause]
readsPrec :: Int -> ReadS DefaultClause
$creadsPrec :: Int -> ReadS DefaultClause
Read,Typeable DefaultClause
DataType
Constr
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 -> DataType
DefaultClause -> Constr
(forall b. Data b => b -> b) -> DefaultClause -> DefaultClause
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefaultClause -> c DefaultClause
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cGenerationClause :: Constr
$cIdentityColumnSpec :: Constr
$cDefaultClause :: Constr
$tDefaultClause :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> DefaultClause -> m DefaultClause
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DefaultClause -> m DefaultClause
gmapQi :: Int -> (forall d. Data d => d -> u) -> DefaultClause -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DefaultClause -> u
gmapQ :: (forall d. Data d => d -> u) -> DefaultClause -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DefaultClause -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DefaultClause -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DefaultClause -> r
gmapT :: (forall b. Data b => b -> b) -> DefaultClause -> DefaultClause
$cgmapT :: (forall b. Data b => b -> b) -> DefaultClause -> DefaultClause
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DefaultClause)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DefaultClause)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DefaultClause)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DefaultClause)
dataTypeOf :: DefaultClause -> DataType
$cdataTypeOf :: DefaultClause -> DataType
toConstr :: DefaultClause -> Constr
$ctoConstr :: DefaultClause -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DefaultClause
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DefaultClause
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefaultClause -> c DefaultClause
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefaultClause -> c DefaultClause
$cp1Data :: Typeable 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
/= :: IdentityWhen -> IdentityWhen -> Bool
$c/= :: IdentityWhen -> IdentityWhen -> Bool
== :: IdentityWhen -> IdentityWhen -> Bool
$c== :: 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
showList :: [IdentityWhen] -> ShowS
$cshowList :: [IdentityWhen] -> ShowS
show :: IdentityWhen -> String
$cshow :: IdentityWhen -> String
showsPrec :: Int -> IdentityWhen -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [IdentityWhen]
$creadListPrec :: ReadPrec [IdentityWhen]
readPrec :: ReadPrec IdentityWhen
$creadPrec :: ReadPrec IdentityWhen
readList :: ReadS [IdentityWhen]
$creadList :: ReadS [IdentityWhen]
readsPrec :: Int -> ReadS IdentityWhen
$creadsPrec :: Int -> ReadS IdentityWhen
Read,Typeable IdentityWhen
DataType
Constr
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 -> DataType
IdentityWhen -> Constr
(forall b. Data b => b -> b) -> IdentityWhen -> IdentityWhen
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IdentityWhen -> c IdentityWhen
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cGeneratedByDefault :: Constr
$cGeneratedAlways :: Constr
$tIdentityWhen :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> IdentityWhen -> m IdentityWhen
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IdentityWhen -> m IdentityWhen
gmapQi :: Int -> (forall d. Data d => d -> u) -> IdentityWhen -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IdentityWhen -> u
gmapQ :: (forall d. Data d => d -> u) -> IdentityWhen -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IdentityWhen -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IdentityWhen -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IdentityWhen -> r
gmapT :: (forall b. Data b => b -> b) -> IdentityWhen -> IdentityWhen
$cgmapT :: (forall b. Data b => b -> b) -> IdentityWhen -> IdentityWhen
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IdentityWhen)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IdentityWhen)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c IdentityWhen)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IdentityWhen)
dataTypeOf :: IdentityWhen -> DataType
$cdataTypeOf :: IdentityWhen -> DataType
toConstr :: IdentityWhen -> Constr
$ctoConstr :: IdentityWhen -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IdentityWhen
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IdentityWhen
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IdentityWhen -> c IdentityWhen
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IdentityWhen -> c IdentityWhen
$cp1Data :: Typeable 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
/= :: SequenceGeneratorOption -> SequenceGeneratorOption -> Bool
$c/= :: SequenceGeneratorOption -> SequenceGeneratorOption -> Bool
== :: SequenceGeneratorOption -> SequenceGeneratorOption -> Bool
$c== :: 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
showList :: [SequenceGeneratorOption] -> ShowS
$cshowList :: [SequenceGeneratorOption] -> ShowS
show :: SequenceGeneratorOption -> String
$cshow :: SequenceGeneratorOption -> String
showsPrec :: Int -> SequenceGeneratorOption -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [SequenceGeneratorOption]
$creadListPrec :: ReadPrec [SequenceGeneratorOption]
readPrec :: ReadPrec SequenceGeneratorOption
$creadPrec :: ReadPrec SequenceGeneratorOption
readList :: ReadS [SequenceGeneratorOption]
$creadList :: ReadS [SequenceGeneratorOption]
readsPrec :: Int -> ReadS SequenceGeneratorOption
$creadsPrec :: Int -> ReadS SequenceGeneratorOption
Read,Typeable SequenceGeneratorOption
DataType
Constr
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 -> DataType
SequenceGeneratorOption -> Constr
(forall b. Data b => b -> b)
-> SequenceGeneratorOption -> SequenceGeneratorOption
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SequenceGeneratorOption
-> c SequenceGeneratorOption
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cSGONoCycle :: Constr
$cSGOCycle :: Constr
$cSGONoMinValue :: Constr
$cSGOMinValue :: Constr
$cSGONoMaxValue :: Constr
$cSGOMaxValue :: Constr
$cSGOIncrementBy :: Constr
$cSGORestart :: Constr
$cSGOStartWith :: Constr
$cSGODataType :: Constr
$tSequenceGeneratorOption :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> SequenceGeneratorOption -> m SequenceGeneratorOption
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SequenceGeneratorOption -> m SequenceGeneratorOption
gmapQi :: Int -> (forall d. Data d => d -> u) -> SequenceGeneratorOption -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SequenceGeneratorOption -> u
gmapQ :: (forall d. Data d => d -> u) -> SequenceGeneratorOption -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> SequenceGeneratorOption -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> SequenceGeneratorOption
-> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> SequenceGeneratorOption
-> r
gmapT :: (forall b. Data b => b -> b)
-> SequenceGeneratorOption -> SequenceGeneratorOption
$cgmapT :: (forall b. Data b => b -> b)
-> SequenceGeneratorOption -> SequenceGeneratorOption
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SequenceGeneratorOption)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SequenceGeneratorOption)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SequenceGeneratorOption)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SequenceGeneratorOption)
dataTypeOf :: SequenceGeneratorOption -> DataType
$cdataTypeOf :: SequenceGeneratorOption -> DataType
toConstr :: SequenceGeneratorOption -> Constr
$ctoConstr :: SequenceGeneratorOption -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SequenceGeneratorOption
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SequenceGeneratorOption
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SequenceGeneratorOption
-> c SequenceGeneratorOption
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SequenceGeneratorOption
-> c SequenceGeneratorOption
$cp1Data :: Typeable 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
/= :: CheckOption -> CheckOption -> Bool
$c/= :: CheckOption -> CheckOption -> Bool
== :: CheckOption -> CheckOption -> Bool
$c== :: 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
showList :: [CheckOption] -> ShowS
$cshowList :: [CheckOption] -> ShowS
show :: CheckOption -> String
$cshow :: CheckOption -> String
showsPrec :: Int -> CheckOption -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [CheckOption]
$creadListPrec :: ReadPrec [CheckOption]
readPrec :: ReadPrec CheckOption
$creadPrec :: ReadPrec CheckOption
readList :: ReadS [CheckOption]
$creadList :: ReadS [CheckOption]
readsPrec :: Int -> ReadS CheckOption
$creadsPrec :: Int -> ReadS CheckOption
Read,Typeable CheckOption
DataType
Constr
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 -> DataType
CheckOption -> Constr
(forall b. Data b => b -> b) -> CheckOption -> CheckOption
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CheckOption -> c CheckOption
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cLocalCheckOption :: Constr
$cCascadedCheckOption :: Constr
$cDefaultCheckOption :: Constr
$tCheckOption :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> CheckOption -> m CheckOption
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CheckOption -> m CheckOption
gmapQi :: Int -> (forall d. Data d => d -> u) -> CheckOption -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CheckOption -> u
gmapQ :: (forall d. Data d => d -> u) -> CheckOption -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CheckOption -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CheckOption -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CheckOption -> r
gmapT :: (forall b. Data b => b -> b) -> CheckOption -> CheckOption
$cgmapT :: (forall b. Data b => b -> b) -> CheckOption -> CheckOption
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CheckOption)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CheckOption)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CheckOption)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CheckOption)
dataTypeOf :: CheckOption -> DataType
$cdataTypeOf :: CheckOption -> DataType
toConstr :: CheckOption -> Constr
$ctoConstr :: CheckOption -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CheckOption
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CheckOption
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CheckOption -> c CheckOption
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CheckOption -> c CheckOption
$cp1Data :: Typeable 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
/= :: AlterDomainAction -> AlterDomainAction -> Bool
$c/= :: AlterDomainAction -> AlterDomainAction -> Bool
== :: AlterDomainAction -> AlterDomainAction -> Bool
$c== :: 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
showList :: [AlterDomainAction] -> ShowS
$cshowList :: [AlterDomainAction] -> ShowS
show :: AlterDomainAction -> String
$cshow :: AlterDomainAction -> String
showsPrec :: Int -> AlterDomainAction -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [AlterDomainAction]
$creadListPrec :: ReadPrec [AlterDomainAction]
readPrec :: ReadPrec AlterDomainAction
$creadPrec :: ReadPrec AlterDomainAction
readList :: ReadS [AlterDomainAction]
$creadList :: ReadS [AlterDomainAction]
readsPrec :: Int -> ReadS AlterDomainAction
$creadsPrec :: Int -> ReadS AlterDomainAction
Read,Typeable AlterDomainAction
DataType
Constr
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 -> DataType
AlterDomainAction -> Constr
(forall b. Data b => b -> b)
-> AlterDomainAction -> AlterDomainAction
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlterDomainAction -> c AlterDomainAction
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cADDropConstraint :: Constr
$cADAddConstraint :: Constr
$cADDropDefault :: Constr
$cADSetDefault :: Constr
$tAlterDomainAction :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> AlterDomainAction -> m AlterDomainAction
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AlterDomainAction -> m AlterDomainAction
gmapQi :: Int -> (forall d. Data d => d -> u) -> AlterDomainAction -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> AlterDomainAction -> u
gmapQ :: (forall d. Data d => d -> u) -> AlterDomainAction -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AlterDomainAction -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlterDomainAction -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlterDomainAction -> r
gmapT :: (forall b. Data b => b -> b)
-> AlterDomainAction -> AlterDomainAction
$cgmapT :: (forall b. Data b => b -> b)
-> AlterDomainAction -> AlterDomainAction
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AlterDomainAction)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AlterDomainAction)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c AlterDomainAction)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlterDomainAction)
dataTypeOf :: AlterDomainAction -> DataType
$cdataTypeOf :: AlterDomainAction -> DataType
toConstr :: AlterDomainAction -> Constr
$ctoConstr :: AlterDomainAction -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlterDomainAction
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlterDomainAction
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlterDomainAction -> c AlterDomainAction
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlterDomainAction -> c AlterDomainAction
$cp1Data :: Typeable 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
/= :: AdminOption -> AdminOption -> Bool
$c/= :: AdminOption -> AdminOption -> Bool
== :: AdminOption -> AdminOption -> Bool
$c== :: 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
showList :: [AdminOption] -> ShowS
$cshowList :: [AdminOption] -> ShowS
show :: AdminOption -> String
$cshow :: AdminOption -> String
showsPrec :: Int -> AdminOption -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [AdminOption]
$creadListPrec :: ReadPrec [AdminOption]
readPrec :: ReadPrec AdminOption
$creadPrec :: ReadPrec AdminOption
readList :: ReadS [AdminOption]
$creadList :: ReadS [AdminOption]
readsPrec :: Int -> ReadS AdminOption
$creadsPrec :: Int -> ReadS AdminOption
Read,Typeable AdminOption
DataType
Constr
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 -> DataType
AdminOption -> Constr
(forall b. Data b => b -> b) -> AdminOption -> AdminOption
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AdminOption -> c AdminOption
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cWithoutAdminOption :: Constr
$cWithAdminOption :: Constr
$tAdminOption :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> AdminOption -> m AdminOption
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AdminOption -> m AdminOption
gmapQi :: Int -> (forall d. Data d => d -> u) -> AdminOption -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AdminOption -> u
gmapQ :: (forall d. Data d => d -> u) -> AdminOption -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AdminOption -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AdminOption -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AdminOption -> r
gmapT :: (forall b. Data b => b -> b) -> AdminOption -> AdminOption
$cgmapT :: (forall b. Data b => b -> b) -> AdminOption -> AdminOption
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AdminOption)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AdminOption)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c AdminOption)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AdminOption)
dataTypeOf :: AdminOption -> DataType
$cdataTypeOf :: AdminOption -> DataType
toConstr :: AdminOption -> Constr
$ctoConstr :: AdminOption -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AdminOption
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AdminOption
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AdminOption -> c AdminOption
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AdminOption -> c AdminOption
$cp1Data :: Typeable 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
/= :: GrantOption -> GrantOption -> Bool
$c/= :: GrantOption -> GrantOption -> Bool
== :: GrantOption -> GrantOption -> Bool
$c== :: 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
showList :: [GrantOption] -> ShowS
$cshowList :: [GrantOption] -> ShowS
show :: GrantOption -> String
$cshow :: GrantOption -> String
showsPrec :: Int -> GrantOption -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [GrantOption]
$creadListPrec :: ReadPrec [GrantOption]
readPrec :: ReadPrec GrantOption
$creadPrec :: ReadPrec GrantOption
readList :: ReadS [GrantOption]
$creadList :: ReadS [GrantOption]
readsPrec :: Int -> ReadS GrantOption
$creadsPrec :: Int -> ReadS GrantOption
Read,Typeable GrantOption
DataType
Constr
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 -> DataType
GrantOption -> Constr
(forall b. Data b => b -> b) -> GrantOption -> GrantOption
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GrantOption -> c GrantOption
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cWithoutGrantOption :: Constr
$cWithGrantOption :: Constr
$tGrantOption :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d) -> GrantOption -> m GrantOption
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GrantOption -> m GrantOption
gmapQi :: Int -> (forall d. Data d => d -> u) -> GrantOption -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GrantOption -> u
gmapQ :: (forall d. Data d => d -> u) -> GrantOption -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GrantOption -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GrantOption -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GrantOption -> r
gmapT :: (forall b. Data b => b -> b) -> GrantOption -> GrantOption
$cgmapT :: (forall b. Data b => b -> b) -> GrantOption -> GrantOption
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GrantOption)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GrantOption)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c GrantOption)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GrantOption)
dataTypeOf :: GrantOption -> DataType
$cdataTypeOf :: GrantOption -> DataType
toConstr :: GrantOption -> Constr
$ctoConstr :: GrantOption -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GrantOption
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GrantOption
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GrantOption -> c GrantOption
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GrantOption -> c GrantOption
$cp1Data :: Typeable 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
/= :: AdminOptionFor -> AdminOptionFor -> Bool
$c/= :: AdminOptionFor -> AdminOptionFor -> Bool
== :: AdminOptionFor -> AdminOptionFor -> Bool
$c== :: 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
showList :: [AdminOptionFor] -> ShowS
$cshowList :: [AdminOptionFor] -> ShowS
show :: AdminOptionFor -> String
$cshow :: AdminOptionFor -> String
showsPrec :: Int -> AdminOptionFor -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [AdminOptionFor]
$creadListPrec :: ReadPrec [AdminOptionFor]
readPrec :: ReadPrec AdminOptionFor
$creadPrec :: ReadPrec AdminOptionFor
readList :: ReadS [AdminOptionFor]
$creadList :: ReadS [AdminOptionFor]
readsPrec :: Int -> ReadS AdminOptionFor
$creadsPrec :: Int -> ReadS AdminOptionFor
Read,Typeable AdminOptionFor
DataType
Constr
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 -> DataType
AdminOptionFor -> Constr
(forall b. Data b => b -> b) -> AdminOptionFor -> AdminOptionFor
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AdminOptionFor -> c AdminOptionFor
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cNoAdminOptionFor :: Constr
$cAdminOptionFor :: Constr
$tAdminOptionFor :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> AdminOptionFor -> m AdminOptionFor
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> AdminOptionFor -> m AdminOptionFor
gmapQi :: Int -> (forall d. Data d => d -> u) -> AdminOptionFor -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> AdminOptionFor -> u
gmapQ :: (forall d. Data d => d -> u) -> AdminOptionFor -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AdminOptionFor -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AdminOptionFor -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AdminOptionFor -> r
gmapT :: (forall b. Data b => b -> b) -> AdminOptionFor -> AdminOptionFor
$cgmapT :: (forall b. Data b => b -> b) -> AdminOptionFor -> AdminOptionFor
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AdminOptionFor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AdminOptionFor)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c AdminOptionFor)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AdminOptionFor)
dataTypeOf :: AdminOptionFor -> DataType
$cdataTypeOf :: AdminOptionFor -> DataType
toConstr :: AdminOptionFor -> Constr
$ctoConstr :: AdminOptionFor -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AdminOptionFor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AdminOptionFor
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AdminOptionFor -> c AdminOptionFor
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AdminOptionFor -> c AdminOptionFor
$cp1Data :: Typeable 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
/= :: GrantOptionFor -> GrantOptionFor -> Bool
$c/= :: GrantOptionFor -> GrantOptionFor -> Bool
== :: GrantOptionFor -> GrantOptionFor -> Bool
$c== :: 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
showList :: [GrantOptionFor] -> ShowS
$cshowList :: [GrantOptionFor] -> ShowS
show :: GrantOptionFor -> String
$cshow :: GrantOptionFor -> String
showsPrec :: Int -> GrantOptionFor -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [GrantOptionFor]
$creadListPrec :: ReadPrec [GrantOptionFor]
readPrec :: ReadPrec GrantOptionFor
$creadPrec :: ReadPrec GrantOptionFor
readList :: ReadS [GrantOptionFor]
$creadList :: ReadS [GrantOptionFor]
readsPrec :: Int -> ReadS GrantOptionFor
$creadsPrec :: Int -> ReadS GrantOptionFor
Read,Typeable GrantOptionFor
DataType
Constr
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 -> DataType
GrantOptionFor -> Constr
(forall b. Data b => b -> b) -> GrantOptionFor -> GrantOptionFor
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GrantOptionFor -> c GrantOptionFor
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cNoGrantOptionFor :: Constr
$cGrantOptionFor :: Constr
$tGrantOptionFor :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> GrantOptionFor -> m GrantOptionFor
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GrantOptionFor -> m GrantOptionFor
gmapQi :: Int -> (forall d. Data d => d -> u) -> GrantOptionFor -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> GrantOptionFor -> u
gmapQ :: (forall d. Data d => d -> u) -> GrantOptionFor -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GrantOptionFor -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GrantOptionFor -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GrantOptionFor -> r
gmapT :: (forall b. Data b => b -> b) -> GrantOptionFor -> GrantOptionFor
$cgmapT :: (forall b. Data b => b -> b) -> GrantOptionFor -> GrantOptionFor
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GrantOptionFor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GrantOptionFor)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c GrantOptionFor)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GrantOptionFor)
dataTypeOf :: GrantOptionFor -> DataType
$cdataTypeOf :: GrantOptionFor -> DataType
toConstr :: GrantOptionFor -> Constr
$ctoConstr :: GrantOptionFor -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GrantOptionFor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GrantOptionFor
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GrantOptionFor -> c GrantOptionFor
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GrantOptionFor -> c GrantOptionFor
$cp1Data :: Typeable 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
/= :: PrivilegeObject -> PrivilegeObject -> Bool
$c/= :: PrivilegeObject -> PrivilegeObject -> Bool
== :: PrivilegeObject -> PrivilegeObject -> Bool
$c== :: 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
showList :: [PrivilegeObject] -> ShowS
$cshowList :: [PrivilegeObject] -> ShowS
show :: PrivilegeObject -> String
$cshow :: PrivilegeObject -> String
showsPrec :: Int -> PrivilegeObject -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [PrivilegeObject]
$creadListPrec :: ReadPrec [PrivilegeObject]
readPrec :: ReadPrec PrivilegeObject
$creadPrec :: ReadPrec PrivilegeObject
readList :: ReadS [PrivilegeObject]
$creadList :: ReadS [PrivilegeObject]
readsPrec :: Int -> ReadS PrivilegeObject
$creadsPrec :: Int -> ReadS PrivilegeObject
Read,Typeable PrivilegeObject
DataType
Constr
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 -> DataType
PrivilegeObject -> Constr
(forall b. Data b => b -> b) -> PrivilegeObject -> PrivilegeObject
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrivilegeObject -> c PrivilegeObject
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cPrivFunction :: Constr
$cPrivSequence :: Constr
$cPrivType :: Constr
$cPrivDomain :: Constr
$cPrivTable :: Constr
$tPrivilegeObject :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> PrivilegeObject -> m PrivilegeObject
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PrivilegeObject -> m PrivilegeObject
gmapQi :: Int -> (forall d. Data d => d -> u) -> PrivilegeObject -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PrivilegeObject -> u
gmapQ :: (forall d. Data d => d -> u) -> PrivilegeObject -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PrivilegeObject -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrivilegeObject -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrivilegeObject -> r
gmapT :: (forall b. Data b => b -> b) -> PrivilegeObject -> PrivilegeObject
$cgmapT :: (forall b. Data b => b -> b) -> PrivilegeObject -> PrivilegeObject
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrivilegeObject)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrivilegeObject)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PrivilegeObject)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrivilegeObject)
dataTypeOf :: PrivilegeObject -> DataType
$cdataTypeOf :: PrivilegeObject -> DataType
toConstr :: PrivilegeObject -> Constr
$ctoConstr :: PrivilegeObject -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrivilegeObject
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrivilegeObject
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrivilegeObject -> c PrivilegeObject
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrivilegeObject -> c PrivilegeObject
$cp1Data :: Typeable 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
/= :: PrivilegeAction -> PrivilegeAction -> Bool
$c/= :: PrivilegeAction -> PrivilegeAction -> Bool
== :: PrivilegeAction -> PrivilegeAction -> Bool
$c== :: 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
showList :: [PrivilegeAction] -> ShowS
$cshowList :: [PrivilegeAction] -> ShowS
show :: PrivilegeAction -> String
$cshow :: PrivilegeAction -> String
showsPrec :: Int -> PrivilegeAction -> ShowS
$cshowsPrec :: Int -> 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
readListPrec :: ReadPrec [PrivilegeAction]
$creadListPrec :: ReadPrec [PrivilegeAction]
readPrec :: ReadPrec PrivilegeAction
$creadPrec :: ReadPrec PrivilegeAction
readList :: ReadS [PrivilegeAction]
$creadList :: ReadS [PrivilegeAction]
readsPrec :: Int -> ReadS PrivilegeAction
$creadsPrec :: Int -> ReadS PrivilegeAction
Read,Typeable PrivilegeAction
DataType
Constr
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 -> DataType
PrivilegeAction -> Constr
(forall b. Data b => b -> b) -> PrivilegeAction -> PrivilegeAction
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrivilegeAction -> c PrivilegeAction
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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)
$cPrivExecute :: Constr
$cPrivTrigger :: Constr
$cPrivUsage :: Constr
$cPrivReferences :: Constr
$cPrivUpdate :: Constr
$cPrivInsert :: Constr
$cPrivDelete :: Constr
$cPrivSelect :: Constr
$cPrivAll :: Constr
$tPrivilegeAction :: DataType
gmapMo :: (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
gmapMp :: (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
gmapM :: (forall d. Data d => d -> m d)
-> PrivilegeAction -> m PrivilegeAction
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PrivilegeAction -> m PrivilegeAction
gmapQi :: Int -> (forall d. Data d => d -> u) -> PrivilegeAction -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PrivilegeAction -> u
gmapQ :: (forall d. Data d => d -> u) -> PrivilegeAction -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PrivilegeAction -> [u]
gmapQr :: (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
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrivilegeAction -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrivilegeAction -> r
gmapT :: (forall b. Data b => b -> b) -> PrivilegeAction -> PrivilegeAction
$cgmapT :: (forall b. Data b => b -> b) -> PrivilegeAction -> PrivilegeAction
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrivilegeAction)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrivilegeAction)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PrivilegeAction)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrivilegeAction)
dataTypeOf :: PrivilegeAction -> DataType
$cdataTypeOf :: PrivilegeAction -> DataType
toConstr :: PrivilegeAction -> Constr
$ctoConstr :: PrivilegeAction -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrivilegeAction
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrivilegeAction
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrivilegeAction -> c PrivilegeAction
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrivilegeAction -> c PrivilegeAction
$cp1Data :: Typeable PrivilegeAction
Data,Typeable)

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