Safe Haskell	None
Language	Haskell2010

Database.HsSqlPpp.Syntax

Contents

Name and TypeName
Scalar expressions
Query expressions
Statements
utility
misc

Description

This module contains the ast node data types. They are very permissive, in that they allow a lot of invalid SQL to be represented. The type checking process should catch all invalid trees, but doesn't quite manage at the moment. Sorry about all the seemingly pointless type synonyms below, they are an artefact of using UUAGC. You can see labels for the fields by looking at the ag source here: https://github.com/JakeWheat/hssqlppp/blob/master/src/Database/HsSqlPpp/Internals/AstInternal.ag

Synopsis

Name and TypeName

data Name Source #

Constructors

Name Annotation [NameComponent]
AntiName String

Instances

Eq Name Source #
Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Data Name Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name # toConstr :: Name -> Constr # dataTypeOf :: Name -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Name) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) # gmapT :: (forall b. Data b => b -> b) -> Name -> Name # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r # gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name #
Show Name Source #
Methods showsPrec :: Int -> Name -> ShowS # show :: Name -> String # showList :: [Name] -> ShowS #

data NameComponent Source #

Constructors

Nmc String
QNmc String
AntiNameComponent String

Instances

Eq NameComponent Source #
Methods (==) :: NameComponent -> NameComponent -> Bool # (/=) :: NameComponent -> NameComponent -> Bool #
Data NameComponent Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameComponent -> c NameComponent # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameComponent # toConstr :: NameComponent -> Constr # dataTypeOf :: NameComponent -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c NameComponent) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameComponent) # gmapT :: (forall b. Data b => b -> b) -> NameComponent -> NameComponent # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameComponent -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameComponent -> r # gmapQ :: (forall d. Data d => d -> u) -> NameComponent -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NameComponent -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameComponent -> m NameComponent # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameComponent -> m NameComponent # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameComponent -> m NameComponent #
Ord NameComponent Source #
Methods compare :: NameComponent -> NameComponent -> Ordering # (<) :: NameComponent -> NameComponent -> Bool # (<=) :: NameComponent -> NameComponent -> Bool # (>) :: NameComponent -> NameComponent -> Bool # (>=) :: NameComponent -> NameComponent -> Bool # max :: NameComponent -> NameComponent -> NameComponent # min :: NameComponent -> NameComponent -> NameComponent #
Show NameComponent Source #
Methods showsPrec :: Int -> NameComponent -> ShowS # show :: NameComponent -> String # showList :: [NameComponent] -> ShowS #

nameComponents :: Name -> [NameComponent] Source #

ncStr :: NameComponent -> String Source #

data TypeName Source #

Constructors

SimpleTypeName Annotation Name
PrecTypeName Annotation Name Integer
Prec2TypeName Annotation Name Integer Integer
ArrayTypeName Annotation TypeName
SetOfTypeName Annotation TypeName

Instances

Eq TypeName Source #
Methods (==) :: TypeName -> TypeName -> Bool # (/=) :: TypeName -> TypeName -> Bool #
Data TypeName Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeName -> c TypeName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeName # toConstr :: TypeName -> Constr # dataTypeOf :: TypeName -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c TypeName) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeName) # gmapT :: (forall b. Data b => b -> b) -> TypeName -> TypeName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeName -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeName -> r # gmapQ :: (forall d. Data d => d -> u) -> TypeName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeName -> m TypeName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeName -> m TypeName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeName -> m TypeName #
Show TypeName Source #
Methods showsPrec :: Int -> TypeName -> ShowS # show :: TypeName -> String # showList :: [TypeName] -> ShowS #

Scalar expressions

data ScalarExpr Source #

Constructors

NumberLit Annotation String
StringLit Annotation String
NullLit Annotation
BooleanLit Annotation Bool
TypedStringLit Annotation TypeName String
Interval Annotation String IntervalField (Maybe Int)
Identifier Annotation Name
Star Annotation
QStar Annotation NameComponent
PositionalArg Annotation Integer
Placeholder Annotation
PrefixOp Annotation Name ScalarExpr
PostfixOp Annotation Name ScalarExpr
BinaryOp Annotation Name ScalarExpr ScalarExpr
SpecialOp Annotation Name ScalarExprList
Extract Annotation ExtractField ScalarExpr
App Annotation Name ScalarExprList
AggregateApp Annotation Distinct ScalarExpr ScalarExprDirectionPairList
WindowApp Annotation ScalarExpr ScalarExprList ScalarExprDirectionPairList (Maybe FrameClause)
Cast Annotation ScalarExpr TypeName
ImplicitCast Annotation ScalarExpr TypeExtra
Case Annotation CaseScalarExprListScalarExprPairList MaybeScalarExpr
CaseSimple Annotation ScalarExpr CaseScalarExprListScalarExprPairList MaybeScalarExpr
Parens Annotation ScalarExpr
InPredicate Annotation ScalarExpr Bool InList
Exists Annotation QueryExpr
ScalarSubQuery Annotation QueryExpr
LiftApp Annotation Name LiftFlavour ScalarExprList
OdbcLiteral Annotation OdbcLiteralType String
OdbcFunc Annotation ScalarExpr
AntiScalarExpr String

Instances

Eq ScalarExpr Source #
Methods (==) :: ScalarExpr -> ScalarExpr -> Bool # (/=) :: ScalarExpr -> ScalarExpr -> Bool #
Data ScalarExpr Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ScalarExpr -> c ScalarExpr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ScalarExpr # toConstr :: ScalarExpr -> Constr # dataTypeOf :: ScalarExpr -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c ScalarExpr) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ScalarExpr) # gmapT :: (forall b. Data b => b -> b) -> ScalarExpr -> ScalarExpr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ScalarExpr -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ScalarExpr -> r # gmapQ :: (forall d. Data d => d -> u) -> ScalarExpr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ScalarExpr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr #
Show ScalarExpr Source #
Methods showsPrec :: Int -> ScalarExpr -> ShowS # show :: ScalarExpr -> String # showList :: [ScalarExpr] -> ShowS #

data InList Source #

Constructors

InList Annotation ScalarExprList
InQueryExpr Annotation QueryExpr

Instances

Eq InList Source #
Methods (==) :: InList -> InList -> Bool # (/=) :: InList -> InList -> Bool #
Data InList Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InList -> c InList # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InList # toConstr :: InList -> Constr # dataTypeOf :: InList -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c InList) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InList) # gmapT :: (forall b. Data b => b -> b) -> InList -> InList # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InList -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InList -> r # gmapQ :: (forall d. Data d => d -> u) -> InList -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> InList -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> InList -> m InList # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InList -> m InList # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InList -> m InList #
Show InList Source #
Methods showsPrec :: Int -> InList -> ShowS # show :: InList -> String # showList :: [InList] -> ShowS #

data LiftFlavour Source #

Constructors

LiftAny
LiftAll

Instances

Eq LiftFlavour Source #
Methods (==) :: LiftFlavour -> LiftFlavour -> Bool # (/=) :: LiftFlavour -> LiftFlavour -> Bool #
Data LiftFlavour Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LiftFlavour -> c LiftFlavour # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LiftFlavour # toConstr :: LiftFlavour -> Constr # dataTypeOf :: LiftFlavour -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c LiftFlavour) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LiftFlavour) # gmapT :: (forall b. Data b => b -> b) -> LiftFlavour -> LiftFlavour # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LiftFlavour -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LiftFlavour -> r # gmapQ :: (forall d. Data d => d -> u) -> LiftFlavour -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> LiftFlavour -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> LiftFlavour -> m LiftFlavour # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LiftFlavour -> m LiftFlavour # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LiftFlavour -> m LiftFlavour #
Show LiftFlavour Source #
Methods showsPrec :: Int -> LiftFlavour -> ShowS # show :: LiftFlavour -> String # showList :: [LiftFlavour] -> ShowS #

data Direction Source #

Constructors

Asc
Desc

Instances

Eq Direction Source #
Methods (==) :: Direction -> Direction -> Bool # (/=) :: Direction -> Direction -> Bool #
Data Direction Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Direction -> c Direction # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Direction # toConstr :: Direction -> Constr # dataTypeOf :: Direction -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Direction) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Direction) # gmapT :: (forall b. Data b => b -> b) -> Direction -> Direction # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Direction -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Direction -> r # gmapQ :: (forall d. Data d => d -> u) -> Direction -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Direction -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Direction -> m Direction # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Direction -> m Direction # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Direction -> m Direction #
Show Direction Source #
Methods showsPrec :: Int -> Direction -> ShowS # show :: Direction -> String # showList :: [Direction] -> ShowS #

data NullsOrder Source #

Constructors

NullsDefault
NullsFirst
NullsLast

Instances

Eq NullsOrder Source #
Methods (==) :: NullsOrder -> NullsOrder -> Bool # (/=) :: NullsOrder -> NullsOrder -> Bool #
Data NullsOrder Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NullsOrder -> c NullsOrder # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NullsOrder # toConstr :: NullsOrder -> Constr # dataTypeOf :: NullsOrder -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c NullsOrder) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NullsOrder) # gmapT :: (forall b. Data b => b -> b) -> NullsOrder -> NullsOrder # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NullsOrder -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NullsOrder -> r # gmapQ :: (forall d. Data d => d -> u) -> NullsOrder -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NullsOrder -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder #
Show NullsOrder Source #
Methods showsPrec :: Int -> NullsOrder -> ShowS # show :: NullsOrder -> String # showList :: [NullsOrder] -> ShowS #

data Distinct Source #

Constructors

Distinct
All

Instances

Eq Distinct Source #
Methods (==) :: Distinct -> Distinct -> Bool # (/=) :: Distinct -> Distinct -> Bool #
Data Distinct Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Distinct -> c Distinct # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Distinct # toConstr :: Distinct -> Constr # dataTypeOf :: Distinct -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Distinct) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Distinct) # gmapT :: (forall b. Data b => b -> b) -> Distinct -> Distinct # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Distinct -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Distinct -> r # gmapQ :: (forall d. Data d => d -> u) -> Distinct -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Distinct -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Distinct -> m Distinct # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Distinct -> m Distinct # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Distinct -> m Distinct #
Show Distinct Source #
Methods showsPrec :: Int -> Distinct -> ShowS # show :: Distinct -> String # showList :: [Distinct] -> ShowS #

data CombineType Source #

Constructors

Except
Union
Intersect
UnionAll

Instances

Eq CombineType Source #
Methods (==) :: CombineType -> CombineType -> Bool # (/=) :: CombineType -> CombineType -> Bool #
Data CombineType Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CombineType -> c CombineType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CombineType # toConstr :: CombineType -> Constr # dataTypeOf :: CombineType -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c CombineType) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CombineType) # gmapT :: (forall b. Data b => b -> b) -> CombineType -> CombineType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CombineType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CombineType -> r # gmapQ :: (forall d. Data d => d -> u) -> CombineType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CombineType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CombineType -> m CombineType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CombineType -> m CombineType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CombineType -> m CombineType #
Show CombineType Source #
Methods showsPrec :: Int -> CombineType -> ShowS # show :: CombineType -> String # showList :: [CombineType] -> ShowS #

data IntervalField Source #

Constructors

IntervalYear
IntervalMonth
IntervalDay
IntervalHour
IntervalMinute
IntervalSecond
IntervalYearToMonth
IntervalDayToHour
IntervalDayToMinute
IntervalDayToSecond
IntervalHourToMinute
IntervalHourToSecond
IntervalMinuteToSecond

Instances

Eq IntervalField Source #
Methods (==) :: IntervalField -> IntervalField -> Bool # (/=) :: IntervalField -> IntervalField -> Bool #
Data IntervalField Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntervalField -> c IntervalField # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IntervalField # toConstr :: IntervalField -> Constr # dataTypeOf :: IntervalField -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c IntervalField) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IntervalField) # gmapT :: (forall b. Data b => b -> b) -> IntervalField -> IntervalField # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntervalField -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntervalField -> r # gmapQ :: (forall d. Data d => d -> u) -> IntervalField -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IntervalField -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IntervalField -> m IntervalField # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IntervalField -> m IntervalField # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IntervalField -> m IntervalField #
Show IntervalField Source #
Methods showsPrec :: Int -> IntervalField -> ShowS # show :: IntervalField -> String # showList :: [IntervalField] -> ShowS #

data ExtractField Source #

Instances

Eq ExtractField Source #
Methods (==) :: ExtractField -> ExtractField -> Bool # (/=) :: ExtractField -> ExtractField -> Bool #
Data ExtractField Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExtractField -> c ExtractField # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ExtractField # toConstr :: ExtractField -> Constr # dataTypeOf :: ExtractField -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c ExtractField) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExtractField) # gmapT :: (forall b. Data b => b -> b) -> ExtractField -> ExtractField # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExtractField -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExtractField -> r # gmapQ :: (forall d. Data d => d -> u) -> ExtractField -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ExtractField -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExtractField -> m ExtractField # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExtractField -> m ExtractField # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExtractField -> m ExtractField #
Show ExtractField Source #
Methods showsPrec :: Int -> ExtractField -> ShowS # show :: ExtractField -> String # showList :: [ExtractField] -> ShowS #

data FrameClause Source #

Constructors

FrameUnboundedPreceding
FrameUnboundedFull
FrameRowsUnboundedPreceding

Instances

Eq FrameClause Source #
Methods (==) :: FrameClause -> FrameClause -> Bool # (/=) :: FrameClause -> FrameClause -> Bool #
Data FrameClause Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FrameClause -> c FrameClause # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FrameClause # toConstr :: FrameClause -> Constr # dataTypeOf :: FrameClause -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c FrameClause) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FrameClause) # gmapT :: (forall b. Data b => b -> b) -> FrameClause -> FrameClause # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FrameClause -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FrameClause -> r # gmapQ :: (forall d. Data d => d -> u) -> FrameClause -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FrameClause -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FrameClause -> m FrameClause # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FrameClause -> m FrameClause # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FrameClause -> m FrameClause #
Show FrameClause Source #
Methods showsPrec :: Int -> FrameClause -> ShowS # show :: FrameClause -> String # showList :: [FrameClause] -> ShowS #

data OdbcLiteralType Source #

Constructors

OLDate
OLTime
OLTimestamp

Instances

Eq OdbcLiteralType Source #
Methods (==) :: OdbcLiteralType -> OdbcLiteralType -> Bool # (/=) :: OdbcLiteralType -> OdbcLiteralType -> Bool #
Data OdbcLiteralType Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OdbcLiteralType -> c OdbcLiteralType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OdbcLiteralType # toConstr :: OdbcLiteralType -> Constr # dataTypeOf :: OdbcLiteralType -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c OdbcLiteralType) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OdbcLiteralType) # gmapT :: (forall b. Data b => b -> b) -> OdbcLiteralType -> OdbcLiteralType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OdbcLiteralType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OdbcLiteralType -> r # gmapQ :: (forall d. Data d => d -> u) -> OdbcLiteralType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OdbcLiteralType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OdbcLiteralType -> m OdbcLiteralType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OdbcLiteralType -> m OdbcLiteralType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OdbcLiteralType -> m OdbcLiteralType #
Show OdbcLiteralType Source #
Methods showsPrec :: Int -> OdbcLiteralType -> ShowS # show :: OdbcLiteralType -> String # showList :: [OdbcLiteralType] -> ShowS #

Query expressions

data QueryExpr Source #

Constructors

Select
Fields ann :: Annotation selDistinct :: Distinct selSelectList :: SelectList selTref :: TableRefList selWhere :: MaybeBoolExpr selGroupBy :: ScalarExprList selHaving :: MaybeBoolExpr selOrderBy :: ScalarExprDirectionPairList selLimit :: MaybeScalarExpr selOffset :: MaybeScalarExpr selOption :: [QueryHint]
CombineQueryExpr
Fields ann :: Annotation cqType :: CombineType cqQe0 :: QueryExpr cqQe1 :: QueryExpr
Values
Fields ann :: Annotation qeValues :: ScalarExprListList
WithQueryExpr
Fields ann :: Annotation withs :: WithQueryList withQe :: QueryExpr

Instances

Eq QueryExpr Source #
Methods (==) :: QueryExpr -> QueryExpr -> Bool # (/=) :: QueryExpr -> QueryExpr -> Bool #
Data QueryExpr Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QueryExpr -> c QueryExpr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c QueryExpr # toConstr :: QueryExpr -> Constr # dataTypeOf :: QueryExpr -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c QueryExpr) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QueryExpr) # gmapT :: (forall b. Data b => b -> b) -> QueryExpr -> QueryExpr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QueryExpr -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QueryExpr -> r # gmapQ :: (forall d. Data d => d -> u) -> QueryExpr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> QueryExpr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr #
Show QueryExpr Source #
Methods showsPrec :: Int -> QueryExpr -> ShowS # show :: QueryExpr -> String # showList :: [QueryExpr] -> ShowS #

makeSelect :: QueryExpr Source #

'default' valued select, use for creating select values

makeSelect :: QueryExpr
makeSelect = Select
             {ann = emptyAnnotation
             ,selDistinct = All
             ,selSelectList = (SelectList emptyAnnotation [])
             ,selTref = []
             ,selWhere = Nothing
             ,selGroupBy = []
             ,selHaving = Nothing
             ,selOrderBy = []
             ,selLimit = Nothing
             ,selOffset = Nothing
             ,selOption = []}

On its own, it isn't valid syntax: to use it you have to replace the select list at minimum

use something like this

s = makeSelect {selSelectList = sl [se $ i "a"]
               ,selTref = [tref "t"]}
    where
        a = emptyAnnotation
        sl = SelectList a
        se = SelExp a
        i = Identifier a
        tref t = Tref a (Name a [Nmc t])

data WithQuery Source #

Constructors

WithQuery Annotation NameComponent (Maybe [NameComponent]) QueryExpr

Instances

Eq WithQuery Source #
Methods (==) :: WithQuery -> WithQuery -> Bool # (/=) :: WithQuery -> WithQuery -> Bool #
Data WithQuery Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WithQuery -> c WithQuery # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WithQuery # toConstr :: WithQuery -> Constr # dataTypeOf :: WithQuery -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c WithQuery) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WithQuery) # gmapT :: (forall b. Data b => b -> b) -> WithQuery -> WithQuery # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WithQuery -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WithQuery -> r # gmapQ :: (forall d. Data d => d -> u) -> WithQuery -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WithQuery -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WithQuery -> m WithQuery # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WithQuery -> m WithQuery # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WithQuery -> m WithQuery #
Show WithQuery Source #
Methods showsPrec :: Int -> WithQuery -> ShowS # show :: WithQuery -> String # showList :: [WithQuery] -> ShowS #

data SelectList Source #

Constructors

SelectList Annotation SelectItemList

Instances

Eq SelectList Source #
Methods (==) :: SelectList -> SelectList -> Bool # (/=) :: SelectList -> SelectList -> Bool #
Data SelectList Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SelectList -> c SelectList # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SelectList # toConstr :: SelectList -> Constr # dataTypeOf :: SelectList -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c SelectList) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SelectList) # gmapT :: (forall b. Data b => b -> b) -> SelectList -> SelectList # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SelectList -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SelectList -> r # gmapQ :: (forall d. Data d => d -> u) -> SelectList -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SelectList -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SelectList -> m SelectList # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectList -> m SelectList # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectList -> m SelectList #
Show SelectList Source #
Methods showsPrec :: Int -> SelectList -> ShowS # show :: SelectList -> String # showList :: [SelectList] -> ShowS #

data SelectItem Source #

Constructors

SelExp Annotation ScalarExpr
SelectItem Annotation ScalarExpr NameComponent

Instances

Eq SelectItem Source #
Methods (==) :: SelectItem -> SelectItem -> Bool # (/=) :: SelectItem -> SelectItem -> Bool #
Data SelectItem Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SelectItem -> c SelectItem # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SelectItem # toConstr :: SelectItem -> Constr # dataTypeOf :: SelectItem -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c SelectItem) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SelectItem) # gmapT :: (forall b. Data b => b -> b) -> SelectItem -> SelectItem # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SelectItem -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SelectItem -> r # gmapQ :: (forall d. Data d => d -> u) -> SelectItem -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SelectItem -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SelectItem -> m SelectItem # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectItem -> m SelectItem # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SelectItem -> m SelectItem #
Show SelectItem Source #
Methods showsPrec :: Int -> SelectItem -> ShowS # show :: SelectItem -> String # showList :: [SelectItem] -> ShowS #

data TableRef Source #

Instances

Eq TableRef Source #
Methods (==) :: TableRef -> TableRef -> Bool # (/=) :: TableRef -> TableRef -> Bool #
Data TableRef Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TableRef -> c TableRef # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TableRef # toConstr :: TableRef -> Constr # dataTypeOf :: TableRef -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c TableRef) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableRef) # gmapT :: (forall b. Data b => b -> b) -> TableRef -> TableRef # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TableRef -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TableRef -> r # gmapQ :: (forall d. Data d => d -> u) -> TableRef -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TableRef -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TableRef -> m TableRef # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TableRef -> m TableRef # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TableRef -> m TableRef #
Show TableRef Source #
Methods showsPrec :: Int -> TableRef -> ShowS # show :: TableRef -> String # showList :: [TableRef] -> ShowS #

data JoinExpr Source #

Constructors

JoinOn Annotation ScalarExpr
JoinUsing Annotation [NameComponent]

Instances

Eq JoinExpr Source #
Methods (==) :: JoinExpr -> JoinExpr -> Bool # (/=) :: JoinExpr -> JoinExpr -> Bool #
Data JoinExpr Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JoinExpr -> c JoinExpr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c JoinExpr # toConstr :: JoinExpr -> Constr # dataTypeOf :: JoinExpr -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c JoinExpr) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinExpr) # gmapT :: (forall b. Data b => b -> b) -> JoinExpr -> JoinExpr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> JoinExpr -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> JoinExpr -> r # gmapQ :: (forall d. Data d => d -> u) -> JoinExpr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> JoinExpr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> JoinExpr -> m JoinExpr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinExpr -> m JoinExpr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinExpr -> m JoinExpr #
Show JoinExpr Source #
Methods showsPrec :: Int -> JoinExpr -> ShowS # show :: JoinExpr -> String # showList :: [JoinExpr] -> ShowS #

data JoinType Source #

Constructors

Inner
LeftOuter
RightOuter
FullOuter
Cross

Instances

Eq JoinType Source #
Methods (==) :: JoinType -> JoinType -> Bool # (/=) :: JoinType -> JoinType -> Bool #
Data JoinType Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JoinType -> c JoinType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c JoinType # toConstr :: JoinType -> Constr # dataTypeOf :: JoinType -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c JoinType) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinType) # gmapT :: (forall b. Data b => b -> b) -> JoinType -> JoinType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> JoinType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> JoinType -> r # gmapQ :: (forall d. Data d => d -> u) -> JoinType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> JoinType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> JoinType -> m JoinType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinType -> m JoinType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinType -> m JoinType #
Show JoinType Source #
Methods showsPrec :: Int -> JoinType -> ShowS # show :: JoinType -> String # showList :: [JoinType] -> ShowS #

data JoinHint Source #

Constructors

Loop
Hash
Merge

Instances

Eq JoinHint Source #
Methods (==) :: JoinHint -> JoinHint -> Bool # (/=) :: JoinHint -> JoinHint -> Bool #
Data JoinHint Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JoinHint -> c JoinHint # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c JoinHint # toConstr :: JoinHint -> Constr # dataTypeOf :: JoinHint -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c JoinHint) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinHint) # gmapT :: (forall b. Data b => b -> b) -> JoinHint -> JoinHint # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> JoinHint -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> JoinHint -> r # gmapQ :: (forall d. Data d => d -> u) -> JoinHint -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> JoinHint -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> JoinHint -> m JoinHint # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinHint -> m JoinHint # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinHint -> m JoinHint #
Show JoinHint Source #
Methods showsPrec :: Int -> JoinHint -> ShowS # show :: JoinHint -> String # showList :: [JoinHint] -> ShowS #

data QueryHint Source #

Constructors

QueryHintPartitionGroup
QueryHintColumnarHostGroup

Instances

Eq QueryHint Source #
Methods (==) :: QueryHint -> QueryHint -> Bool # (/=) :: QueryHint -> QueryHint -> Bool #
Data QueryHint Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QueryHint -> c QueryHint # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c QueryHint # toConstr :: QueryHint -> Constr # dataTypeOf :: QueryHint -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c QueryHint) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QueryHint) # gmapT :: (forall b. Data b => b -> b) -> QueryHint -> QueryHint # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QueryHint -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QueryHint -> r # gmapQ :: (forall d. Data d => d -> u) -> QueryHint -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> QueryHint -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> QueryHint -> m QueryHint # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QueryHint -> m QueryHint # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QueryHint -> m QueryHint #
Show QueryHint Source #
Methods showsPrec :: Int -> QueryHint -> ShowS # show :: QueryHint -> String # showList :: [QueryHint] -> ShowS #

type OnExpr = Maybe JoinExpr Source #

data Natural Source #

Constructors

Natural
Unnatural

Instances

Eq Natural Source #
Methods (==) :: Natural -> Natural -> Bool # (/=) :: Natural -> Natural -> Bool #
Data Natural Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Natural -> c Natural # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Natural # toConstr :: Natural -> Constr # dataTypeOf :: Natural -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Natural) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Natural) # gmapT :: (forall b. Data b => b -> b) -> Natural -> Natural # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r # gmapQ :: (forall d. Data d => d -> u) -> Natural -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Natural -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Natural -> m Natural # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural #
Show Natural Source #
Methods showsPrec :: Int -> Natural -> ShowS # show :: Natural -> String # showList :: [Natural] -> ShowS #

Statements

data Statement Source #

Constructors

QueryStatement Annotation QueryExpr
Insert Annotation Name [NameComponent] QueryExpr MaybeSelectList
Update Annotation Name SetClauseList TableRefList MaybeBoolExpr MaybeSelectList
Delete Annotation Name TableRefList MaybeBoolExpr MaybeSelectList
CopyFrom Annotation Name [NameComponent] CopyFromSource [CopyFromOption]
CopyData Annotation String
CopyTo Annotation CopyToSource String [CopyToOption]
Truncate Annotation [Name] RestartIdentity Cascade
CreateTable Annotation Name AttributeDefList ConstraintList MaybeTablePartitionDef Replace
AlterTable Annotation Name AlterTableOperation
AlterDatabase Annotation Name AlterDatabaseOperation
CreateSequence Annotation Name Integer (Maybe Integer) (Maybe Integer) Integer Integer
AlterSequence Annotation Name AlterSequenceOperation
CreateTableAs Annotation Name Replace QueryExpr
CreateView Annotation Name MaybeNameComponentList QueryExpr
AlterView Annotation Name MaybeNameComponentList QueryExpr
CreateType Annotation Name TypeAttributeDefList
CreateUser Annotation Name String
CreateLogin Annotation Name String
AlterUser Annotation Name String
AlterLogin Annotation Name String
CreateSchema Annotation NameComponent (Maybe Name)
AlterSchema Annotation NameComponent AlterSchemaOperation
CreateFunction Annotation Name ParamDefList TypeName Replace Language FnBody Volatility
CreateDomain Annotation Name TypeName String MaybeBoolExpr
CreateLanguage Annotation String
CreateTrigger Annotation NameComponent TriggerWhen [TriggerEvent] Name TriggerFire Name ScalarExprList
DropFunction Annotation IfExists NameTypeNameListPairList Cascade
DropSomething Annotation DropType IfExists [Name] Cascade
DropTrigger Annotation IfExists NameComponent Name Cascade
CreateDatabase Annotation Name
Set Annotation String [SetValue]
Notify Annotation String
Into Annotation Bool [Name] Statement
Assignment Annotation Name ScalarExpr
Return Annotation MaybeScalarExpr
ReturnNext Annotation ScalarExpr
ReturnQuery Annotation QueryExpr
Raise Annotation RaiseType String ScalarExprList
NullStatement Annotation
Perform Annotation ScalarExpr
Execute Annotation ScalarExpr
ForQueryStatement Annotation (Maybe String) NameComponent QueryExpr StatementList
ForIntegerStatement Annotation (Maybe String) NameComponent ScalarExpr ScalarExpr StatementList
LoopStatement Annotation (Maybe String) StatementList
WhileStatement Annotation (Maybe String) ScalarExpr StatementList
ContinueStatement Annotation (Maybe String)
ExitStatement Annotation (Maybe String)
CaseStatementSimple Annotation ScalarExpr ScalarExprListStatementListTripleList StatementList
CaseStatement Annotation ScalarExprListStatementListTripleList StatementList
If Annotation ScalarExprStatementListPairList StatementList
Block Annotation (Maybe String) VarDefList StatementList
AntiStatement String
DeclareStatement Annotation [(String, TypeName, Maybe ScalarExpr)]
ExecStatement Annotation Name ScalarExprList
CreateIndexTSQL Annotation NameComponent Name [NameComponent]

Instances

Eq Statement Source #
Methods (==) :: Statement -> Statement -> Bool # (/=) :: Statement -> Statement -> Bool #
Data Statement Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Statement -> c Statement # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Statement # toConstr :: Statement -> Constr # dataTypeOf :: Statement -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Statement) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement) # gmapT :: (forall b. Data b => b -> b) -> Statement -> Statement # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Statement -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Statement -> r # gmapQ :: (forall d. Data d => d -> u) -> Statement -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Statement -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Statement -> m Statement # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Statement -> m Statement # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Statement -> m Statement #
Show Statement Source #
Methods showsPrec :: Int -> Statement -> ShowS # show :: Statement -> String # showList :: [Statement] -> ShowS #

dml components

data CopyToSource Source #

Constructors

CopyTable Name [NameComponent]
CopyQuery QueryExpr

Instances

Eq CopyToSource Source #
Methods (==) :: CopyToSource -> CopyToSource -> Bool # (/=) :: CopyToSource -> CopyToSource -> Bool #
Data CopyToSource Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CopyToSource -> c CopyToSource # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CopyToSource # toConstr :: CopyToSource -> Constr # dataTypeOf :: CopyToSource -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c CopyToSource) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CopyToSource) # gmapT :: (forall b. Data b => b -> b) -> CopyToSource -> CopyToSource # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CopyToSource -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CopyToSource -> r # gmapQ :: (forall d. Data d => d -> u) -> CopyToSource -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CopyToSource -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CopyToSource -> m CopyToSource # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CopyToSource -> m CopyToSource # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CopyToSource -> m CopyToSource #
Show CopyToSource Source #
Methods showsPrec :: Int -> CopyToSource -> ShowS # show :: CopyToSource -> String # showList :: [CopyToSource] -> ShowS #

data CopyFromSource Source #

Constructors

CopyFilename String
Stdin

Instances

Eq CopyFromSource Source #
Methods (==) :: CopyFromSource -> CopyFromSource -> Bool # (/=) :: CopyFromSource -> CopyFromSource -> Bool #
Data CopyFromSource Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CopyFromSource -> c CopyFromSource # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CopyFromSource # toConstr :: CopyFromSource -> Constr # dataTypeOf :: CopyFromSource -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c CopyFromSource) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CopyFromSource) # gmapT :: (forall b. Data b => b -> b) -> CopyFromSource -> CopyFromSource # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CopyFromSource -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CopyFromSource -> r # gmapQ :: (forall d. Data d => d -> u) -> CopyFromSource -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CopyFromSource -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CopyFromSource -> m CopyFromSource # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CopyFromSource -> m CopyFromSource # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CopyFromSource -> m CopyFromSource #
Show CopyFromSource Source #
Methods showsPrec :: Int -> CopyFromSource -> ShowS # show :: CopyFromSource -> String # showList :: [CopyFromSource] -> ShowS #

data CopyToOption Source #

Constructors

CopyToFormat String
CopyToDelimiter String
CopyToErrorLog String
CopyToErrorVerbosity Int

Instances

Eq CopyToOption Source #
Methods (==) :: CopyToOption -> CopyToOption -> Bool # (/=) :: CopyToOption -> CopyToOption -> Bool #
Data CopyToOption Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CopyToOption -> c CopyToOption # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CopyToOption # toConstr :: CopyToOption -> Constr # dataTypeOf :: CopyToOption -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c CopyToOption) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CopyToOption) # gmapT :: (forall b. Data b => b -> b) -> CopyToOption -> CopyToOption # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CopyToOption -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CopyToOption -> r # gmapQ :: (forall d. Data d => d -> u) -> CopyToOption -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CopyToOption -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CopyToOption -> m CopyToOption # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CopyToOption -> m CopyToOption # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CopyToOption -> m CopyToOption #
Show CopyToOption Source #
Methods showsPrec :: Int -> CopyToOption -> ShowS # show :: CopyToOption -> String # showList :: [CopyToOption] -> ShowS #

data CopyFromOption Source #

Constructors

CopyFromFormat String
CopyFromDelimiter String
CopyFromErrorLog String
CopyFromErrorVerbosity Int
CopyFromParsers String
CopyFromDirectory
CopyFromOffset Integer
CopyFromLimit Integer
CopyFromErrorThreshold Int
CopyFromNewlineFormat String

Instances

Eq CopyFromOption Source #
Methods (==) :: CopyFromOption -> CopyFromOption -> Bool # (/=) :: CopyFromOption -> CopyFromOption -> Bool #
Data CopyFromOption Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CopyFromOption -> c CopyFromOption # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CopyFromOption # toConstr :: CopyFromOption -> Constr # dataTypeOf :: CopyFromOption -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c CopyFromOption) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CopyFromOption) # gmapT :: (forall b. Data b => b -> b) -> CopyFromOption -> CopyFromOption # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CopyFromOption -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CopyFromOption -> r # gmapQ :: (forall d. Data d => d -> u) -> CopyFromOption -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CopyFromOption -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CopyFromOption -> m CopyFromOption # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CopyFromOption -> m CopyFromOption # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CopyFromOption -> m CopyFromOption #
Show CopyFromOption Source #
Methods showsPrec :: Int -> CopyFromOption -> ShowS # show :: CopyFromOption -> String # showList :: [CopyFromOption] -> ShowS #

data SetClause Source #

Constructors

SetClause Annotation NameComponent ScalarExpr
MultiSetClause Annotation [NameComponent] ScalarExpr

Instances

Eq SetClause Source #
Methods (==) :: SetClause -> SetClause -> Bool # (/=) :: SetClause -> SetClause -> Bool #
Data SetClause Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SetClause -> c SetClause # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SetClause # toConstr :: SetClause -> Constr # dataTypeOf :: SetClause -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c SetClause) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SetClause) # gmapT :: (forall b. Data b => b -> b) -> SetClause -> SetClause # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SetClause -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SetClause -> r # gmapQ :: (forall d. Data d => d -> u) -> SetClause -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SetClause -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SetClause -> m SetClause # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SetClause -> m SetClause # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SetClause -> m SetClause #
Show SetClause Source #
Methods showsPrec :: Int -> SetClause -> ShowS # show :: SetClause -> String # showList :: [SetClause] -> ShowS #

ddl components

data AttributeDef Source #

Constructors

AttributeDef Annotation NameComponent TypeName MaybeScalarExpr RowConstraintList

Instances

Eq AttributeDef Source #
Methods (==) :: AttributeDef -> AttributeDef -> Bool # (/=) :: AttributeDef -> AttributeDef -> Bool #
Data AttributeDef Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AttributeDef -> c AttributeDef # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AttributeDef # toConstr :: AttributeDef -> Constr # dataTypeOf :: AttributeDef -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c AttributeDef) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AttributeDef) # gmapT :: (forall b. Data b => b -> b) -> AttributeDef -> AttributeDef # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AttributeDef -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AttributeDef -> r # gmapQ :: (forall d. Data d => d -> u) -> AttributeDef -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AttributeDef -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AttributeDef -> m AttributeDef # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AttributeDef -> m AttributeDef # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AttributeDef -> m AttributeDef #
Show AttributeDef Source #
Methods showsPrec :: Int -> AttributeDef -> ShowS # show :: AttributeDef -> String # showList :: [AttributeDef] -> ShowS #

data RowConstraint Source #

Instances

Eq RowConstraint Source #
Methods (==) :: RowConstraint -> RowConstraint -> Bool # (/=) :: RowConstraint -> RowConstraint -> Bool #
Data RowConstraint Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RowConstraint -> c RowConstraint # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RowConstraint # toConstr :: RowConstraint -> Constr # dataTypeOf :: RowConstraint -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c RowConstraint) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RowConstraint) # gmapT :: (forall b. Data b => b -> b) -> RowConstraint -> RowConstraint # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RowConstraint -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RowConstraint -> r # gmapQ :: (forall d. Data d => d -> u) -> RowConstraint -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RowConstraint -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RowConstraint -> m RowConstraint # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RowConstraint -> m RowConstraint # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RowConstraint -> m RowConstraint #
Show RowConstraint Source #
Methods showsPrec :: Int -> RowConstraint -> ShowS # show :: RowConstraint -> String # showList :: [RowConstraint] -> ShowS #

data Constraint Source #

Instances

Eq Constraint Source #
Methods (==) :: Constraint -> Constraint -> Bool # (/=) :: Constraint -> Constraint -> Bool #
Data Constraint Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Constraint -> c Constraint # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Constraint # toConstr :: Constraint -> Constr # dataTypeOf :: Constraint -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Constraint) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Constraint) # gmapT :: (forall b. Data b => b -> b) -> Constraint -> Constraint # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Constraint -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Constraint -> r # gmapQ :: (forall d. Data d => d -> u) -> Constraint -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Constraint -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Constraint -> m Constraint # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Constraint -> m Constraint # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Constraint -> m Constraint #
Show Constraint Source #
Methods showsPrec :: Int -> Constraint -> ShowS # show :: Constraint -> String # showList :: [Constraint] -> ShowS #

data TablePartitionDef Source #

Constructors

TablePartitionDef Annotation NameComponent Integer TablePartitionDateTimeInterval

Instances

Eq TablePartitionDef Source #
Methods (==) :: TablePartitionDef -> TablePartitionDef -> Bool # (/=) :: TablePartitionDef -> TablePartitionDef -> Bool #
Data TablePartitionDef Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TablePartitionDef -> c TablePartitionDef # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TablePartitionDef # toConstr :: TablePartitionDef -> Constr # dataTypeOf :: TablePartitionDef -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c TablePartitionDef) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TablePartitionDef) # gmapT :: (forall b. Data b => b -> b) -> TablePartitionDef -> TablePartitionDef # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TablePartitionDef -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TablePartitionDef -> r # gmapQ :: (forall d. Data d => d -> u) -> TablePartitionDef -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TablePartitionDef -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TablePartitionDef -> m TablePartitionDef # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TablePartitionDef -> m TablePartitionDef # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TablePartitionDef -> m TablePartitionDef #
Show TablePartitionDef Source #
Methods showsPrec :: Int -> TablePartitionDef -> ShowS # show :: TablePartitionDef -> String # showList :: [TablePartitionDef] -> ShowS #

data TablePartitionDateTimeInterval Source #

Constructors

Year
Month
Day
Hour
Minute
Second
Millisecond

Instances

Eq TablePartitionDateTimeInterval Source #
Methods (==) :: TablePartitionDateTimeInterval -> TablePartitionDateTimeInterval -> Bool # (/=) :: TablePartitionDateTimeInterval -> TablePartitionDateTimeInterval -> Bool #
Data TablePartitionDateTimeInterval Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TablePartitionDateTimeInterval -> c TablePartitionDateTimeInterval # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TablePartitionDateTimeInterval # toConstr :: TablePartitionDateTimeInterval -> Constr # dataTypeOf :: TablePartitionDateTimeInterval -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c TablePartitionDateTimeInterval) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TablePartitionDateTimeInterval) # gmapT :: (forall b. Data b => b -> b) -> TablePartitionDateTimeInterval -> TablePartitionDateTimeInterval # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TablePartitionDateTimeInterval -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TablePartitionDateTimeInterval -> r # gmapQ :: (forall d. Data d => d -> u) -> TablePartitionDateTimeInterval -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TablePartitionDateTimeInterval -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TablePartitionDateTimeInterval -> m TablePartitionDateTimeInterval # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TablePartitionDateTimeInterval -> m TablePartitionDateTimeInterval # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TablePartitionDateTimeInterval -> m TablePartitionDateTimeInterval #
Show TablePartitionDateTimeInterval Source #
Methods showsPrec :: Int -> TablePartitionDateTimeInterval -> ShowS # show :: TablePartitionDateTimeInterval -> String # showList :: [TablePartitionDateTimeInterval] -> ShowS #

data TypeAttributeDef Source #

Constructors

TypeAttDef Annotation NameComponent TypeName

Instances

Eq TypeAttributeDef Source #
Methods (==) :: TypeAttributeDef -> TypeAttributeDef -> Bool # (/=) :: TypeAttributeDef -> TypeAttributeDef -> Bool #
Data TypeAttributeDef Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeAttributeDef -> c TypeAttributeDef # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeAttributeDef # toConstr :: TypeAttributeDef -> Constr # dataTypeOf :: TypeAttributeDef -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c TypeAttributeDef) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeAttributeDef) # gmapT :: (forall b. Data b => b -> b) -> TypeAttributeDef -> TypeAttributeDef # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeAttributeDef -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeAttributeDef -> r # gmapQ :: (forall d. Data d => d -> u) -> TypeAttributeDef -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeAttributeDef -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeAttributeDef -> m TypeAttributeDef # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeAttributeDef -> m TypeAttributeDef # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeAttributeDef -> m TypeAttributeDef #
Show TypeAttributeDef Source #
Methods showsPrec :: Int -> TypeAttributeDef -> ShowS # show :: TypeAttributeDef -> String # showList :: [TypeAttributeDef] -> ShowS #

data AlterDatabaseOperation Source #

Constructors

RenameDatabase Annotation Name

Instances

Eq AlterDatabaseOperation Source #
Methods (==) :: AlterDatabaseOperation -> AlterDatabaseOperation -> Bool # (/=) :: AlterDatabaseOperation -> AlterDatabaseOperation -> Bool #
Data AlterDatabaseOperation Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AlterDatabaseOperation -> c AlterDatabaseOperation # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AlterDatabaseOperation # toConstr :: AlterDatabaseOperation -> Constr # dataTypeOf :: AlterDatabaseOperation -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c AlterDatabaseOperation) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlterDatabaseOperation) # gmapT :: (forall b. Data b => b -> b) -> AlterDatabaseOperation -> AlterDatabaseOperation # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AlterDatabaseOperation -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AlterDatabaseOperation -> r # gmapQ :: (forall d. Data d => d -> u) -> AlterDatabaseOperation -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AlterDatabaseOperation -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AlterDatabaseOperation -> m AlterDatabaseOperation # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterDatabaseOperation -> m AlterDatabaseOperation # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterDatabaseOperation -> m AlterDatabaseOperation #
Show AlterDatabaseOperation Source #
Methods showsPrec :: Int -> AlterDatabaseOperation -> ShowS # show :: AlterDatabaseOperation -> String # showList :: [AlterDatabaseOperation] -> ShowS #

data AlterSchemaOperation Source #

Constructors

AlterSchemaName Annotation NameComponent
AlterSchemaOwner Annotation Name

Instances

Eq AlterSchemaOperation Source #
Methods (==) :: AlterSchemaOperation -> AlterSchemaOperation -> Bool # (/=) :: AlterSchemaOperation -> AlterSchemaOperation -> Bool #
Data AlterSchemaOperation Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AlterSchemaOperation -> c AlterSchemaOperation # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AlterSchemaOperation # toConstr :: AlterSchemaOperation -> Constr # dataTypeOf :: AlterSchemaOperation -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c AlterSchemaOperation) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlterSchemaOperation) # gmapT :: (forall b. Data b => b -> b) -> AlterSchemaOperation -> AlterSchemaOperation # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AlterSchemaOperation -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AlterSchemaOperation -> r # gmapQ :: (forall d. Data d => d -> u) -> AlterSchemaOperation -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AlterSchemaOperation -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AlterSchemaOperation -> m AlterSchemaOperation # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterSchemaOperation -> m AlterSchemaOperation # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterSchemaOperation -> m AlterSchemaOperation #
Show AlterSchemaOperation Source #
Methods showsPrec :: Int -> AlterSchemaOperation -> ShowS # show :: AlterSchemaOperation -> String # showList :: [AlterSchemaOperation] -> ShowS #

data AlterTableOperation Source #

Constructors

RenameTable Annotation Name
RenameColumn Annotation NameComponent NameComponent
AlterTableActions Annotation AlterTableActionList

Instances

Eq AlterTableOperation Source #
Methods (==) :: AlterTableOperation -> AlterTableOperation -> Bool # (/=) :: AlterTableOperation -> AlterTableOperation -> Bool #
Data AlterTableOperation Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AlterTableOperation -> c AlterTableOperation # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AlterTableOperation # toConstr :: AlterTableOperation -> Constr # dataTypeOf :: AlterTableOperation -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c AlterTableOperation) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlterTableOperation) # gmapT :: (forall b. Data b => b -> b) -> AlterTableOperation -> AlterTableOperation # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AlterTableOperation -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AlterTableOperation -> r # gmapQ :: (forall d. Data d => d -> u) -> AlterTableOperation -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AlterTableOperation -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AlterTableOperation -> m AlterTableOperation # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterTableOperation -> m AlterTableOperation # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterTableOperation -> m AlterTableOperation #
Show AlterTableOperation Source #
Methods showsPrec :: Int -> AlterTableOperation -> ShowS # show :: AlterTableOperation -> String # showList :: [AlterTableOperation] -> ShowS #

data AlterTableAction Source #

Constructors

AddColumn Annotation AttributeDef
DropColumn Annotation NameComponent
AlterColumn Annotation NameComponent AlterColumnAction
AddConstraint Annotation Constraint

Instances

Eq AlterTableAction Source #
Methods (==) :: AlterTableAction -> AlterTableAction -> Bool # (/=) :: AlterTableAction -> AlterTableAction -> Bool #
Data AlterTableAction Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AlterTableAction -> c AlterTableAction # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AlterTableAction # toConstr :: AlterTableAction -> Constr # dataTypeOf :: AlterTableAction -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c AlterTableAction) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlterTableAction) # gmapT :: (forall b. Data b => b -> b) -> AlterTableAction -> AlterTableAction # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AlterTableAction -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AlterTableAction -> r # gmapQ :: (forall d. Data d => d -> u) -> AlterTableAction -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AlterTableAction -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AlterTableAction -> m AlterTableAction # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterTableAction -> m AlterTableAction # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterTableAction -> m AlterTableAction #
Show AlterTableAction Source #
Methods showsPrec :: Int -> AlterTableAction -> ShowS # show :: AlterTableAction -> String # showList :: [AlterTableAction] -> ShowS #

data AlterSequenceOperation Source #

Constructors

AlterSequenceOwned Annotation Name
AlterSequenceRename Annotation Name
AlterSequenceActions Annotation AlterSequenceActionList

Instances

Eq AlterSequenceOperation Source #
Methods (==) :: AlterSequenceOperation -> AlterSequenceOperation -> Bool # (/=) :: AlterSequenceOperation -> AlterSequenceOperation -> Bool #
Data AlterSequenceOperation Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AlterSequenceOperation -> c AlterSequenceOperation # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AlterSequenceOperation # toConstr :: AlterSequenceOperation -> Constr # dataTypeOf :: AlterSequenceOperation -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c AlterSequenceOperation) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlterSequenceOperation) # gmapT :: (forall b. Data b => b -> b) -> AlterSequenceOperation -> AlterSequenceOperation # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AlterSequenceOperation -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AlterSequenceOperation -> r # gmapQ :: (forall d. Data d => d -> u) -> AlterSequenceOperation -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AlterSequenceOperation -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AlterSequenceOperation -> m AlterSequenceOperation # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterSequenceOperation -> m AlterSequenceOperation # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterSequenceOperation -> m AlterSequenceOperation #
Show AlterSequenceOperation Source #
Methods showsPrec :: Int -> AlterSequenceOperation -> ShowS # show :: AlterSequenceOperation -> String # showList :: [AlterSequenceOperation] -> ShowS #

data AlterSequenceAction Source #

Instances

Eq AlterSequenceAction Source #
Methods (==) :: AlterSequenceAction -> AlterSequenceAction -> Bool # (/=) :: AlterSequenceAction -> AlterSequenceAction -> Bool #
Data AlterSequenceAction Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AlterSequenceAction -> c AlterSequenceAction # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AlterSequenceAction # toConstr :: AlterSequenceAction -> Constr # dataTypeOf :: AlterSequenceAction -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c AlterSequenceAction) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlterSequenceAction) # gmapT :: (forall b. Data b => b -> b) -> AlterSequenceAction -> AlterSequenceAction # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AlterSequenceAction -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AlterSequenceAction -> r # gmapQ :: (forall d. Data d => d -> u) -> AlterSequenceAction -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AlterSequenceAction -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AlterSequenceAction -> m AlterSequenceAction # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterSequenceAction -> m AlterSequenceAction # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterSequenceAction -> m AlterSequenceAction #
Show AlterSequenceAction Source #
Methods showsPrec :: Int -> AlterSequenceAction -> ShowS # show :: AlterSequenceAction -> String # showList :: [AlterSequenceAction] -> ShowS #

data AlterColumnAction Source #

run canonicalizeTypeName on all the TypeName nodes in an ast

Constructors

SetDataType Annotation TypeName
SetNotNull Annotation
DropNotNull Annotation
SetDefault Annotation ScalarExpr
DropDefault Annotation

Instances

Eq AlterColumnAction Source #
Methods (==) :: AlterColumnAction -> AlterColumnAction -> Bool # (/=) :: AlterColumnAction -> AlterColumnAction -> Bool #
Data AlterColumnAction Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AlterColumnAction -> c AlterColumnAction # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AlterColumnAction # toConstr :: AlterColumnAction -> Constr # dataTypeOf :: AlterColumnAction -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c AlterColumnAction) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlterColumnAction) # gmapT :: (forall b. Data b => b -> b) -> AlterColumnAction -> AlterColumnAction # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AlterColumnAction -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AlterColumnAction -> r # gmapQ :: (forall d. Data d => d -> u) -> AlterColumnAction -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AlterColumnAction -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AlterColumnAction -> m AlterColumnAction # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterColumnAction -> m AlterColumnAction # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterColumnAction -> m AlterColumnAction #
Show AlterColumnAction Source #
Methods showsPrec :: Int -> AlterColumnAction -> ShowS # show :: AlterColumnAction -> String # showList :: [AlterColumnAction] -> ShowS #

data TriggerWhen Source #

Constructors

TriggerBefore
TriggerAfter

Instances

Eq TriggerWhen Source #
Methods (==) :: TriggerWhen -> TriggerWhen -> Bool # (/=) :: TriggerWhen -> TriggerWhen -> Bool #
Data TriggerWhen Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TriggerWhen -> c TriggerWhen # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TriggerWhen # toConstr :: TriggerWhen -> Constr # dataTypeOf :: TriggerWhen -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c TriggerWhen) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TriggerWhen) # gmapT :: (forall b. Data b => b -> b) -> TriggerWhen -> TriggerWhen # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TriggerWhen -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TriggerWhen -> r # gmapQ :: (forall d. Data d => d -> u) -> TriggerWhen -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TriggerWhen -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TriggerWhen -> m TriggerWhen # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TriggerWhen -> m TriggerWhen # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TriggerWhen -> m TriggerWhen #
Show TriggerWhen Source #
Methods showsPrec :: Int -> TriggerWhen -> ShowS # show :: TriggerWhen -> String # showList :: [TriggerWhen] -> ShowS #

data TriggerEvent Source #

Constructors

TInsert
TUpdate
TDelete
AntiTriggerEvent String

Instances

Eq TriggerEvent Source #
Methods (==) :: TriggerEvent -> TriggerEvent -> Bool # (/=) :: TriggerEvent -> TriggerEvent -> Bool #
Data TriggerEvent Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TriggerEvent -> c TriggerEvent # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TriggerEvent # toConstr :: TriggerEvent -> Constr # dataTypeOf :: TriggerEvent -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c TriggerEvent) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TriggerEvent) # gmapT :: (forall b. Data b => b -> b) -> TriggerEvent -> TriggerEvent # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TriggerEvent -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TriggerEvent -> r # gmapQ :: (forall d. Data d => d -> u) -> TriggerEvent -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TriggerEvent -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TriggerEvent -> m TriggerEvent # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TriggerEvent -> m TriggerEvent # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TriggerEvent -> m TriggerEvent #
Show TriggerEvent Source #
Methods showsPrec :: Int -> TriggerEvent -> ShowS # show :: TriggerEvent -> String # showList :: [TriggerEvent] -> ShowS #

data TriggerFire Source #

Constructors

EachRow
EachStatement

Instances

Eq TriggerFire Source #
Methods (==) :: TriggerFire -> TriggerFire -> Bool # (/=) :: TriggerFire -> TriggerFire -> Bool #
Data TriggerFire Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TriggerFire -> c TriggerFire # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TriggerFire # toConstr :: TriggerFire -> Constr # dataTypeOf :: TriggerFire -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c TriggerFire) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TriggerFire) # gmapT :: (forall b. Data b => b -> b) -> TriggerFire -> TriggerFire # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TriggerFire -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TriggerFire -> r # gmapQ :: (forall d. Data d => d -> u) -> TriggerFire -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TriggerFire -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TriggerFire -> m TriggerFire # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TriggerFire -> m TriggerFire # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TriggerFire -> m TriggerFire #
Show TriggerFire Source #
Methods showsPrec :: Int -> TriggerFire -> ShowS # show :: TriggerFire -> String # showList :: [TriggerFire] -> ShowS #

data DropType Source #

Constructors

Table
Domain
View
Type
Database
User
Login
Schema

Instances

Eq DropType Source #
Methods (==) :: DropType -> DropType -> Bool # (/=) :: DropType -> DropType -> Bool #
Data DropType Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DropType -> c DropType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DropType # toConstr :: DropType -> Constr # dataTypeOf :: DropType -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c DropType) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DropType) # gmapT :: (forall b. Data b => b -> b) -> DropType -> DropType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DropType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DropType -> r # gmapQ :: (forall d. Data d => d -> u) -> DropType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DropType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DropType -> m DropType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DropType -> m DropType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DropType -> m DropType #
Show DropType Source #
Methods showsPrec :: Int -> DropType -> ShowS # show :: DropType -> String # showList :: [DropType] -> ShowS #

data Cascade Source #

Constructors

Cascade
Restrict

Instances

Eq Cascade Source #
Methods (==) :: Cascade -> Cascade -> Bool # (/=) :: Cascade -> Cascade -> Bool #
Data Cascade Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Cascade -> c Cascade # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Cascade # toConstr :: Cascade -> Constr # dataTypeOf :: Cascade -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Cascade) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Cascade) # gmapT :: (forall b. Data b => b -> b) -> Cascade -> Cascade # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Cascade -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Cascade -> r # gmapQ :: (forall d. Data d => d -> u) -> Cascade -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Cascade -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Cascade -> m Cascade # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Cascade -> m Cascade # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Cascade -> m Cascade #
Show Cascade Source #
Methods showsPrec :: Int -> Cascade -> ShowS # show :: Cascade -> String # showList :: [Cascade] -> ShowS #

data IfExists Source #

Constructors

Require
IfExists

Instances

Eq IfExists Source #
Methods (==) :: IfExists -> IfExists -> Bool # (/=) :: IfExists -> IfExists -> Bool #
Data IfExists Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IfExists -> c IfExists # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IfExists # toConstr :: IfExists -> Constr # dataTypeOf :: IfExists -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c IfExists) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IfExists) # gmapT :: (forall b. Data b => b -> b) -> IfExists -> IfExists # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IfExists -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IfExists -> r # gmapQ :: (forall d. Data d => d -> u) -> IfExists -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IfExists -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IfExists -> m IfExists # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IfExists -> m IfExists # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IfExists -> m IfExists #
Show IfExists Source #
Methods showsPrec :: Int -> IfExists -> ShowS # show :: IfExists -> String # showList :: [IfExists] -> ShowS #

data RestartIdentity Source #

Constructors

RestartIdentity
ContinueIdentity

Instances

Eq RestartIdentity Source #
Methods (==) :: RestartIdentity -> RestartIdentity -> Bool # (/=) :: RestartIdentity -> RestartIdentity -> Bool #
Data RestartIdentity Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RestartIdentity -> c RestartIdentity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RestartIdentity # toConstr :: RestartIdentity -> Constr # dataTypeOf :: RestartIdentity -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c RestartIdentity) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RestartIdentity) # gmapT :: (forall b. Data b => b -> b) -> RestartIdentity -> RestartIdentity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RestartIdentity -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RestartIdentity -> r # gmapQ :: (forall d. Data d => d -> u) -> RestartIdentity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RestartIdentity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RestartIdentity -> m RestartIdentity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RestartIdentity -> m RestartIdentity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RestartIdentity -> m RestartIdentity #
Show RestartIdentity Source #
Methods showsPrec :: Int -> RestartIdentity -> ShowS # show :: RestartIdentity -> String # showList :: [RestartIdentity] -> ShowS #

function ddl components

data Replace Source #

Constructors

Replace
NoReplace

Instances

Eq Replace Source #
Methods (==) :: Replace -> Replace -> Bool # (/=) :: Replace -> Replace -> Bool #
Data Replace Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Replace -> c Replace # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Replace # toConstr :: Replace -> Constr # dataTypeOf :: Replace -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Replace) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Replace) # gmapT :: (forall b. Data b => b -> b) -> Replace -> Replace # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Replace -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Replace -> r # gmapQ :: (forall d. Data d => d -> u) -> Replace -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Replace -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Replace -> m Replace # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Replace -> m Replace # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Replace -> m Replace #
Show Replace Source #
Methods showsPrec :: Int -> Replace -> ShowS # show :: Replace -> String # showList :: [Replace] -> ShowS #

data Volatility Source #

Constructors

Volatile
Stable
Immutable

Instances

Eq Volatility Source #
Methods (==) :: Volatility -> Volatility -> Bool # (/=) :: Volatility -> Volatility -> Bool #
Data Volatility Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Volatility -> c Volatility # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Volatility # toConstr :: Volatility -> Constr # dataTypeOf :: Volatility -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Volatility) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Volatility) # gmapT :: (forall b. Data b => b -> b) -> Volatility -> Volatility # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Volatility -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Volatility -> r # gmapQ :: (forall d. Data d => d -> u) -> Volatility -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Volatility -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Volatility -> m Volatility # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Volatility -> m Volatility # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Volatility -> m Volatility #
Show Volatility Source #
Methods showsPrec :: Int -> Volatility -> ShowS # show :: Volatility -> String # showList :: [Volatility] -> ShowS #

data Language Source #

Constructors

Sql
Plpgsql

Instances

Eq Language Source #
Methods (==) :: Language -> Language -> Bool # (/=) :: Language -> Language -> Bool #
Data Language Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Language -> c Language # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Language # toConstr :: Language -> Constr # dataTypeOf :: Language -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Language) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Language) # gmapT :: (forall b. Data b => b -> b) -> Language -> Language # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Language -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Language -> r # gmapQ :: (forall d. Data d => d -> u) -> Language -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Language -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Language -> m Language # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Language -> m Language # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Language -> m Language #
Show Language Source #
Methods showsPrec :: Int -> Language -> ShowS # show :: Language -> String # showList :: [Language] -> ShowS #

data FnBody Source #

Constructors

SqlFnBody Annotation StatementList
PlpgsqlFnBody Annotation Statement

Instances

Eq FnBody Source #
Methods (==) :: FnBody -> FnBody -> Bool # (/=) :: FnBody -> FnBody -> Bool #
Data FnBody Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FnBody -> c FnBody # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FnBody # toConstr :: FnBody -> Constr # dataTypeOf :: FnBody -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c FnBody) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FnBody) # gmapT :: (forall b. Data b => b -> b) -> FnBody -> FnBody # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FnBody -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FnBody -> r # gmapQ :: (forall d. Data d => d -> u) -> FnBody -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FnBody -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FnBody -> m FnBody # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FnBody -> m FnBody # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FnBody -> m FnBody #
Show FnBody Source #
Methods showsPrec :: Int -> FnBody -> ShowS # show :: FnBody -> String # showList :: [FnBody] -> ShowS #

PlPgsql components

data ParamDef Source #

Constructors

ParamDef Annotation NameComponent TypeName
ParamDefTp Annotation TypeName

Instances

Eq ParamDef Source #
Methods (==) :: ParamDef -> ParamDef -> Bool # (/=) :: ParamDef -> ParamDef -> Bool #
Data ParamDef Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ParamDef -> c ParamDef # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ParamDef # toConstr :: ParamDef -> Constr # dataTypeOf :: ParamDef -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c ParamDef) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ParamDef) # gmapT :: (forall b. Data b => b -> b) -> ParamDef -> ParamDef # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ParamDef -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ParamDef -> r # gmapQ :: (forall d. Data d => d -> u) -> ParamDef -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ParamDef -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ParamDef -> m ParamDef # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ParamDef -> m ParamDef # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ParamDef -> m ParamDef #
Show ParamDef Source #
Methods showsPrec :: Int -> ParamDef -> ShowS # show :: ParamDef -> String # showList :: [ParamDef] -> ShowS #

data VarDef Source #

Constructors

VarDef Annotation NameComponent TypeName (Maybe ScalarExpr)
ParamAlias Annotation NameComponent Integer
VarAlias Annotation NameComponent Name

Instances

Eq VarDef Source #
Methods (==) :: VarDef -> VarDef -> Bool # (/=) :: VarDef -> VarDef -> Bool #
Data VarDef Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VarDef -> c VarDef # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VarDef # toConstr :: VarDef -> Constr # dataTypeOf :: VarDef -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VarDef) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarDef) # gmapT :: (forall b. Data b => b -> b) -> VarDef -> VarDef # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VarDef -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VarDef -> r # gmapQ :: (forall d. Data d => d -> u) -> VarDef -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VarDef -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VarDef -> m VarDef # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VarDef -> m VarDef # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VarDef -> m VarDef #
Show VarDef Source #
Methods showsPrec :: Int -> VarDef -> ShowS # show :: VarDef -> String # showList :: [VarDef] -> ShowS #

data RaiseType Source #

Constructors

RNotice
RException
RError

Instances

Eq RaiseType Source #
Methods (==) :: RaiseType -> RaiseType -> Bool # (/=) :: RaiseType -> RaiseType -> Bool #
Data RaiseType Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RaiseType -> c RaiseType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RaiseType # toConstr :: RaiseType -> Constr # dataTypeOf :: RaiseType -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c RaiseType) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RaiseType) # gmapT :: (forall b. Data b => b -> b) -> RaiseType -> RaiseType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RaiseType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RaiseType -> r # gmapQ :: (forall d. Data d => d -> u) -> RaiseType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RaiseType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RaiseType -> m RaiseType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RaiseType -> m RaiseType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RaiseType -> m RaiseType #
Show RaiseType Source #
Methods showsPrec :: Int -> RaiseType -> ShowS # show :: RaiseType -> String # showList :: [RaiseType] -> ShowS #

utility

data SetValue Source #

Constructors

SetStr Annotation String
SetId Annotation String
SetNum Annotation Double

Instances

Eq SetValue Source #
Methods (==) :: SetValue -> SetValue -> Bool # (/=) :: SetValue -> SetValue -> Bool #
Data SetValue Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SetValue -> c SetValue # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SetValue # toConstr :: SetValue -> Constr # dataTypeOf :: SetValue -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c SetValue) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SetValue) # gmapT :: (forall b. Data b => b -> b) -> SetValue -> SetValue # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SetValue -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SetValue -> r # gmapQ :: (forall d. Data d => d -> u) -> SetValue -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SetValue -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SetValue -> m SetValue # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SetValue -> m SetValue # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SetValue -> m SetValue #
Show SetValue Source #
Methods showsPrec :: Int -> SetValue -> ShowS # show :: SetValue -> String # showList :: [SetValue] -> ShowS #

ExtractCentury
ExtractDay
ExtractDecade
ExtractDow
ExtractDoy
ExtractEpoch
ExtractHour
ExtractIsodow
ExtractIsoyear
ExtractMicroseconds
ExtractMillennium
ExtractMilliseconds
ExtractMinute
ExtractMonth
ExtractQuarter
ExtractSecond
ExtractTimezone
ExtractTimezoneHour
ExtractTimezoneMinute
ExtractWeek
ExtractYear

Tref Annotation Name
FunTref Annotation ScalarExpr
SubTref Annotation QueryExpr
JoinTref Annotation TableRef Natural JoinType (Maybe JoinHint) TableRef OnExpr
TableAlias Annotation NameComponent TableRef
FullAlias Annotation NameComponent [NameComponent] TableRef
TableRefParens Annotation TableRef
OdbcTableRef Annotation TableRef

NullConstraint Annotation String
NotNullConstraint Annotation String
IdentityConstraint Annotation String (Maybe (Integer, Integer))
RowCheckConstraint Annotation String ScalarExpr
RowUniqueConstraint Annotation String
RowPrimaryKeyConstraint Annotation String
RowReferenceConstraint Annotation String Name (Maybe NameComponent) Cascade Cascade

UniqueConstraint Annotation String [NameComponent]
PrimaryKeyConstraint Annotation String [NameComponent]
CheckConstraint Annotation String ScalarExpr
ReferenceConstraint Annotation String [NameComponent] Name [NameComponent] Cascade Cascade

AlterSequenceIncrement Annotation Integer
AlterSequenceMin Annotation (Maybe Integer)
AlterSequenceMax Annotation (Maybe Integer)
AlterSequenceStart Annotation Integer
AlterSequenceRestart Annotation (Maybe Integer)
AlterSequenceCache Annotation Integer

Name and TypeName

Scalar expressions

Query expressions

Statements

dml components

ddl components

function ddl components

PlPgsql components

utility

misc