Database.HsSqlPpp.Syntax

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

Name and TypeName

data Name

Constructors

Name Annotation [NameComponent]

AntiName String

Instances

Eq Name

Methods

(==) :: Name -> Name -> Bool

(/=) :: Name -> Name -> Bool

Data Name

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

Methods

showsPrec :: Int -> Name -> ShowS

show :: Name -> String

showList :: [Name] -> ShowS

data NameComponent

Constructors

Nmc String

QNmc String

AntiNameComponent String

Instances

Eq NameComponent

Methods

(==) :: NameComponent -> NameComponent -> Bool

(/=) :: NameComponent -> NameComponent -> Bool

Data NameComponent

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

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

Methods

showsPrec :: Int -> NameComponent -> ShowS

show :: NameComponent -> String

showList :: [NameComponent] -> ShowS

nameComponents :: Name -> [NameComponent]

ncStr :: NameComponent -> String

data TypeName

Constructors

SimpleTypeName Annotation Name

PrecTypeName Annotation Name Integer

Prec2TypeName Annotation Name Integer Integer

ArrayTypeName Annotation TypeName

SetOfTypeName Annotation TypeName

Instances

Eq TypeName

Methods

(==) :: TypeName -> TypeName -> Bool

(/=) :: TypeName -> TypeName -> Bool

Data TypeName

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

Methods

showsPrec :: Int -> TypeName -> ShowS

show :: TypeName -> String

showList :: [TypeName] -> ShowS

Scalar expressions

data ScalarExpr

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

Methods

(==) :: ScalarExpr -> ScalarExpr -> Bool

(/=) :: ScalarExpr -> ScalarExpr -> Bool

Data ScalarExpr

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

Methods

showsPrec :: Int -> ScalarExpr -> ShowS

show :: ScalarExpr -> String

showList :: [ScalarExpr] -> ShowS

data InList

Constructors

InList Annotation ScalarExprList

InQueryExpr Annotation QueryExpr

Instances

Eq InList

Methods

(==) :: InList -> InList -> Bool

(/=) :: InList -> InList -> Bool

Data InList

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

Methods

showsPrec :: Int -> InList -> ShowS

show :: InList -> String

showList :: [InList] -> ShowS

data LiftFlavour

Constructors

LiftAny

LiftAll

Instances

Eq LiftFlavour

Methods

(==) :: LiftFlavour -> LiftFlavour -> Bool

(/=) :: LiftFlavour -> LiftFlavour -> Bool

Data LiftFlavour

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

Methods

showsPrec :: Int -> LiftFlavour -> ShowS

show :: LiftFlavour -> String

showList :: [LiftFlavour] -> ShowS

data Direction

Constructors

Asc

Desc

Instances

Eq Direction

Methods

(==) :: Direction -> Direction -> Bool

(/=) :: Direction -> Direction -> Bool

Data Direction

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

Methods

showsPrec :: Int -> Direction -> ShowS

show :: Direction -> String

showList :: [Direction] -> ShowS

data NullsOrder

Constructors

NullsDefault

NullsFirst

NullsLast

Instances

Eq NullsOrder

Methods

(==) :: NullsOrder -> NullsOrder -> Bool

(/=) :: NullsOrder -> NullsOrder -> Bool

Data NullsOrder

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

Methods

showsPrec :: Int -> NullsOrder -> ShowS

show :: NullsOrder -> String

showList :: [NullsOrder] -> ShowS

data Distinct

Constructors

Distinct

All

Instances

Eq Distinct

Methods

(==) :: Distinct -> Distinct -> Bool

(/=) :: Distinct -> Distinct -> Bool

Data Distinct

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

Methods

showsPrec :: Int -> Distinct -> ShowS

show :: Distinct -> String

showList :: [Distinct] -> ShowS

data CombineType

Constructors

Except

Union

Intersect

UnionAll

Instances

Eq CombineType

Methods

(==) :: CombineType -> CombineType -> Bool

(/=) :: CombineType -> CombineType -> Bool

Data CombineType

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

Methods

showsPrec :: Int -> CombineType -> ShowS

show :: CombineType -> String

showList :: [CombineType] -> ShowS

data IntervalField

Constructors

IntervalYear

IntervalMonth

IntervalDay

IntervalHour

IntervalMinute

IntervalSecond

IntervalYearToMonth

IntervalDayToHour

IntervalDayToMinute

IntervalDayToSecond

IntervalHourToMinute

IntervalHourToSecond

IntervalMinuteToSecond

Instances

Eq IntervalField

Methods

(==) :: IntervalField -> IntervalField -> Bool

(/=) :: IntervalField -> IntervalField -> Bool

Data IntervalField

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

Methods

showsPrec :: Int -> IntervalField -> ShowS

show :: IntervalField -> String

showList :: [IntervalField] -> ShowS

data ExtractField

Constructors

ExtractCentury

ExtractDay

ExtractDecade

ExtractDow

ExtractDoy

ExtractEpoch

ExtractHour

ExtractIsodow

ExtractIsoyear

ExtractMicroseconds

ExtractMillennium

ExtractMilliseconds

ExtractMinute

ExtractMonth

ExtractQuarter

ExtractSecond

ExtractTimezone

ExtractTimezoneHour

ExtractTimezoneMinute

ExtractWeek

ExtractYear

Instances

Eq ExtractField

Methods

(==) :: ExtractField -> ExtractField -> Bool

(/=) :: ExtractField -> ExtractField -> Bool

Data ExtractField

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

Methods

showsPrec :: Int -> ExtractField -> ShowS

show :: ExtractField -> String

showList :: [ExtractField] -> ShowS

data FrameClause

Constructors

FrameUnboundedPreceding

FrameUnboundedFull

FrameRowsUnboundedPreceding

Instances

Eq FrameClause

Methods

(==) :: FrameClause -> FrameClause -> Bool

(/=) :: FrameClause -> FrameClause -> Bool

Data FrameClause

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

Methods

showsPrec :: Int -> FrameClause -> ShowS

show :: FrameClause -> String

showList :: [FrameClause] -> ShowS

data OdbcLiteralType

Constructors

OLDate

OLTime

OLTimestamp

Instances

Eq OdbcLiteralType

Methods

(==) :: OdbcLiteralType -> OdbcLiteralType -> Bool

(/=) :: OdbcLiteralType -> OdbcLiteralType -> Bool

Data OdbcLiteralType

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

Methods

showsPrec :: Int -> OdbcLiteralType -> ShowS

show :: OdbcLiteralType -> String

showList :: [OdbcLiteralType] -> ShowS

Query expressions

data QueryExpr

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

Methods

(==) :: QueryExpr -> QueryExpr -> Bool

(/=) :: QueryExpr -> QueryExpr -> Bool

Data QueryExpr

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

Methods

showsPrec :: Int -> QueryExpr -> ShowS

show :: QueryExpr -> String

showList :: [QueryExpr] -> ShowS

makeSelect :: QueryExpr

'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

Constructors

WithQuery Annotation NameComponent (Maybe [NameComponent]) QueryExpr

Instances

Eq WithQuery

Methods

(==) :: WithQuery -> WithQuery -> Bool

(/=) :: WithQuery -> WithQuery -> Bool

Data WithQuery

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

Methods

showsPrec :: Int -> WithQuery -> ShowS

show :: WithQuery -> String

showList :: [WithQuery] -> ShowS

data SelectList

Constructors

SelectList Annotation SelectItemList

Instances

Eq SelectList

Methods

(==) :: SelectList -> SelectList -> Bool

(/=) :: SelectList -> SelectList -> Bool

Data SelectList

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

Methods

showsPrec :: Int -> SelectList -> ShowS

show :: SelectList -> String

showList :: [SelectList] -> ShowS

data SelectItem

Constructors

SelExp Annotation ScalarExpr

SelectItem Annotation ScalarExpr NameComponent

Instances

Eq SelectItem

Methods

(==) :: SelectItem -> SelectItem -> Bool

(/=) :: SelectItem -> SelectItem -> Bool

Data SelectItem

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

Methods

showsPrec :: Int -> SelectItem -> ShowS

show :: SelectItem -> String

showList :: [SelectItem] -> ShowS

data TableRef

Constructors

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

Instances

Eq TableRef

Methods

(==) :: TableRef -> TableRef -> Bool

(/=) :: TableRef -> TableRef -> Bool

Data TableRef

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

Methods

showsPrec :: Int -> TableRef -> ShowS

show :: TableRef -> String

showList :: [TableRef] -> ShowS

data JoinExpr

Constructors

JoinOn Annotation ScalarExpr

JoinUsing Annotation [NameComponent]

Instances

Eq JoinExpr

Methods

(==) :: JoinExpr -> JoinExpr -> Bool

(/=) :: JoinExpr -> JoinExpr -> Bool

Data JoinExpr

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

Methods

showsPrec :: Int -> JoinExpr -> ShowS

show :: JoinExpr -> String

showList :: [JoinExpr] -> ShowS

data JoinType

Constructors

Inner

LeftOuter

RightOuter

FullOuter

Cross

Instances

Eq JoinType

Methods

(==) :: JoinType -> JoinType -> Bool

(/=) :: JoinType -> JoinType -> Bool

Data JoinType

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

Methods

showsPrec :: Int -> JoinType -> ShowS

show :: JoinType -> String

showList :: [JoinType] -> ShowS

data JoinHint

Constructors

Loop

Hash

Merge

Instances

Eq JoinHint

Methods

(==) :: JoinHint -> JoinHint -> Bool

(/=) :: JoinHint -> JoinHint -> Bool

Data JoinHint

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

Methods

showsPrec :: Int -> JoinHint -> ShowS

show :: JoinHint -> String

showList :: [JoinHint] -> ShowS

data QueryHint

Constructors

QueryHintPartitionGroup

QueryHintColumnarHostGroup

Instances

Eq QueryHint

Methods

(==) :: QueryHint -> QueryHint -> Bool

(/=) :: QueryHint -> QueryHint -> Bool

Data QueryHint

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

Methods

showsPrec :: Int -> QueryHint -> ShowS

show :: QueryHint -> String

showList :: [QueryHint] -> ShowS

type OnExpr = Maybe JoinExpr

data Natural

Constructors

Natural

Unnatural

Instances

Eq Natural

Methods

(==) :: Natural -> Natural -> Bool

(/=) :: Natural -> Natural -> Bool

Data Natural

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

Methods

showsPrec :: Int -> Natural -> ShowS

show :: Natural -> String

showList :: [Natural] -> ShowS

Statements

data Statement

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

Methods

(==) :: Statement -> Statement -> Bool

(/=) :: Statement -> Statement -> Bool

Data Statement

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

Methods

showsPrec :: Int -> Statement -> ShowS

show :: Statement -> String

showList :: [Statement] -> ShowS

dml components

data CopyToSource

Constructors

CopyTable Name [NameComponent]

CopyQuery QueryExpr

Instances

Eq CopyToSource

Methods

(==) :: CopyToSource -> CopyToSource -> Bool

(/=) :: CopyToSource -> CopyToSource -> Bool

Data CopyToSource

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

Methods

showsPrec :: Int -> CopyToSource -> ShowS

show :: CopyToSource -> String

showList :: [CopyToSource] -> ShowS

data CopyFromSource

Constructors

CopyFilename String

Stdin

Instances

Eq CopyFromSource

Methods

(==) :: CopyFromSource -> CopyFromSource -> Bool

(/=) :: CopyFromSource -> CopyFromSource -> Bool

Data CopyFromSource

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

Methods

showsPrec :: Int -> CopyFromSource -> ShowS

show :: CopyFromSource -> String

showList :: [CopyFromSource] -> ShowS

data CopyToOption

Constructors

CopyToFormat String

CopyToDelimiter String

CopyToErrorLog String

CopyToErrorVerbosity Int

Instances

Eq CopyToOption

Methods

(==) :: CopyToOption -> CopyToOption -> Bool

(/=) :: CopyToOption -> CopyToOption -> Bool

Data CopyToOption

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

Methods

showsPrec :: Int -> CopyToOption -> ShowS

show :: CopyToOption -> String

showList :: [CopyToOption] -> ShowS

data CopyFromOption

Constructors

CopyFromFormat String

CopyFromDelimiter String

CopyFromErrorLog String

CopyFromErrorVerbosity Int

CopyFromParsers String

CopyFromDirectory

CopyFromOffset Integer

CopyFromLimit Integer

CopyFromErrorThreshold Int

CopyFromNewlineFormat String

Instances

Eq CopyFromOption

Methods

(==) :: CopyFromOption -> CopyFromOption -> Bool

(/=) :: CopyFromOption -> CopyFromOption -> Bool

Data CopyFromOption

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

Methods

showsPrec :: Int -> CopyFromOption -> ShowS

show :: CopyFromOption -> String

showList :: [CopyFromOption] -> ShowS

data SetClause

Constructors

SetClause Annotation NameComponent ScalarExpr

MultiSetClause Annotation [NameComponent] ScalarExpr

Instances

Eq SetClause

Methods

(==) :: SetClause -> SetClause -> Bool

(/=) :: SetClause -> SetClause -> Bool

Data SetClause

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

Methods

showsPrec :: Int -> SetClause -> ShowS

show :: SetClause -> String

showList :: [SetClause] -> ShowS

ddl components

data AttributeDef

Constructors

AttributeDef Annotation NameComponent TypeName MaybeScalarExpr RowConstraintList

Instances

Eq AttributeDef

Methods

(==) :: AttributeDef -> AttributeDef -> Bool

(/=) :: AttributeDef -> AttributeDef -> Bool

Data AttributeDef

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

Methods

showsPrec :: Int -> AttributeDef -> ShowS

show :: AttributeDef -> String

showList :: [AttributeDef] -> ShowS

data RowConstraint

Constructors

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

Instances

Eq RowConstraint

Methods

(==) :: RowConstraint -> RowConstraint -> Bool

(/=) :: RowConstraint -> RowConstraint -> Bool

Data RowConstraint

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

Methods

showsPrec :: Int -> RowConstraint -> ShowS

show :: RowConstraint -> String

showList :: [RowConstraint] -> ShowS

data Constraint

Constructors

UniqueConstraint Annotation String [NameComponent]

PrimaryKeyConstraint Annotation String [NameComponent]

CheckConstraint Annotation String ScalarExpr

ReferenceConstraint Annotation String [NameComponent] Name [NameComponent] Cascade Cascade

Instances

Eq Constraint

Methods

(==) :: Constraint -> Constraint -> Bool

(/=) :: Constraint -> Constraint -> Bool

Data Constraint

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

Methods

showsPrec :: Int -> Constraint -> ShowS

show :: Constraint -> String

showList :: [Constraint] -> ShowS

data TablePartitionDef

Constructors

TablePartitionDef Annotation NameComponent Integer TablePartitionDateTimeInterval

Instances

Eq TablePartitionDef

Methods

(==) :: TablePartitionDef -> TablePartitionDef -> Bool

(/=) :: TablePartitionDef -> TablePartitionDef -> Bool

Data TablePartitionDef

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

Methods

showsPrec :: Int -> TablePartitionDef -> ShowS

show :: TablePartitionDef -> String

showList :: [TablePartitionDef] -> ShowS

data TablePartitionDateTimeInterval

Constructors

Year

Month

Day

Hour

Minute

Second

Millisecond

Instances

Eq TablePartitionDateTimeInterval

Methods

(==) :: TablePartitionDateTimeInterval -> TablePartitionDateTimeInterval -> Bool

(/=) :: TablePartitionDateTimeInterval -> TablePartitionDateTimeInterval -> Bool

Data TablePartitionDateTimeInterval

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

Methods

showsPrec :: Int -> TablePartitionDateTimeInterval -> ShowS

show :: TablePartitionDateTimeInterval -> String

showList :: [TablePartitionDateTimeInterval] -> ShowS

data TypeAttributeDef

Constructors

TypeAttDef Annotation NameComponent TypeName

Instances

Eq TypeAttributeDef

Methods

(==) :: TypeAttributeDef -> TypeAttributeDef -> Bool

(/=) :: TypeAttributeDef -> TypeAttributeDef -> Bool

Data TypeAttributeDef

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

Methods

showsPrec :: Int -> TypeAttributeDef -> ShowS

show :: TypeAttributeDef -> String

showList :: [TypeAttributeDef] -> ShowS

data AlterDatabaseOperation

Constructors

RenameDatabase Annotation Name

Instances

Eq AlterDatabaseOperation

Methods

(==) :: AlterDatabaseOperation -> AlterDatabaseOperation -> Bool

(/=) :: AlterDatabaseOperation -> AlterDatabaseOperation -> Bool

Data AlterDatabaseOperation

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

Methods

showsPrec :: Int -> AlterDatabaseOperation -> ShowS

show :: AlterDatabaseOperation -> String

showList :: [AlterDatabaseOperation] -> ShowS

data AlterSchemaOperation

Constructors

AlterSchemaName Annotation NameComponent

AlterSchemaOwner Annotation Name

Instances

Eq AlterSchemaOperation

Methods

(==) :: AlterSchemaOperation -> AlterSchemaOperation -> Bool

(/=) :: AlterSchemaOperation -> AlterSchemaOperation -> Bool

Data AlterSchemaOperation

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

Methods

showsPrec :: Int -> AlterSchemaOperation -> ShowS

show :: AlterSchemaOperation -> String

showList :: [AlterSchemaOperation] -> ShowS

data AlterTableOperation

Constructors

RenameTable Annotation Name

RenameColumn Annotation NameComponent NameComponent

AlterTableActions Annotation AlterTableActionList

Instances

Eq AlterTableOperation

Methods

(==) :: AlterTableOperation -> AlterTableOperation -> Bool

(/=) :: AlterTableOperation -> AlterTableOperation -> Bool

Data AlterTableOperation

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

Methods

showsPrec :: Int -> AlterTableOperation -> ShowS

show :: AlterTableOperation -> String

showList :: [AlterTableOperation] -> ShowS

data AlterTableAction

Constructors

AddColumn Annotation AttributeDef

DropColumn Annotation NameComponent

AlterColumn Annotation NameComponent AlterColumnAction

AddConstraint Annotation Constraint

Instances

Eq AlterTableAction

Methods

(==) :: AlterTableAction -> AlterTableAction -> Bool

(/=) :: AlterTableAction -> AlterTableAction -> Bool

Data AlterTableAction

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

Methods

showsPrec :: Int -> AlterTableAction -> ShowS

show :: AlterTableAction -> String

showList :: [AlterTableAction] -> ShowS

data AlterSequenceOperation

Constructors

AlterSequenceOwned Annotation Name

AlterSequenceRename Annotation Name

AlterSequenceActions Annotation AlterSequenceActionList

Instances

Eq AlterSequenceOperation

Methods

(==) :: AlterSequenceOperation -> AlterSequenceOperation -> Bool

(/=) :: AlterSequenceOperation -> AlterSequenceOperation -> Bool

Data AlterSequenceOperation

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

Methods

showsPrec :: Int -> AlterSequenceOperation -> ShowS

show :: AlterSequenceOperation -> String

showList :: [AlterSequenceOperation] -> ShowS

data AlterSequenceAction

Constructors

AlterSequenceIncrement Annotation Integer

AlterSequenceMin Annotation (Maybe Integer)

AlterSequenceMax Annotation (Maybe Integer)

AlterSequenceStart Annotation Integer

AlterSequenceRestart Annotation (Maybe Integer)

AlterSequenceCache Annotation Integer

Instances

Eq AlterSequenceAction

Methods

(==) :: AlterSequenceAction -> AlterSequenceAction -> Bool

(/=) :: AlterSequenceAction -> AlterSequenceAction -> Bool

Data AlterSequenceAction

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

Methods

showsPrec :: Int -> AlterSequenceAction -> ShowS

show :: AlterSequenceAction -> String

showList :: [AlterSequenceAction] -> ShowS

data AlterColumnAction

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

Methods

(==) :: AlterColumnAction -> AlterColumnAction -> Bool

(/=) :: AlterColumnAction -> AlterColumnAction -> Bool

Data AlterColumnAction

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

Methods

showsPrec :: Int -> AlterColumnAction -> ShowS

show :: AlterColumnAction -> String

showList :: [AlterColumnAction] -> ShowS

data TriggerWhen

Constructors

TriggerBefore

TriggerAfter

Instances

Eq TriggerWhen

Methods

(==) :: TriggerWhen -> TriggerWhen -> Bool

(/=) :: TriggerWhen -> TriggerWhen -> Bool

Data TriggerWhen

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

Methods

showsPrec :: Int -> TriggerWhen -> ShowS

show :: TriggerWhen -> String

showList :: [TriggerWhen] -> ShowS

data TriggerEvent

Constructors

TInsert

TUpdate

TDelete

AntiTriggerEvent String

Instances

Eq TriggerEvent

Methods

(==) :: TriggerEvent -> TriggerEvent -> Bool

(/=) :: TriggerEvent -> TriggerEvent -> Bool

Data TriggerEvent

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

Methods

showsPrec :: Int -> TriggerEvent -> ShowS

show :: TriggerEvent -> String

showList :: [TriggerEvent] -> ShowS

data TriggerFire

Constructors

EachRow

EachStatement

Instances

Eq TriggerFire

Methods

(==) :: TriggerFire -> TriggerFire -> Bool

(/=) :: TriggerFire -> TriggerFire -> Bool

Data TriggerFire

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

Methods

showsPrec :: Int -> TriggerFire -> ShowS

show :: TriggerFire -> String

showList :: [TriggerFire] -> ShowS

data DropType

Constructors

Table

Domain

View

Type

Database

User

Login

Schema

Instances

Eq DropType

Methods

(==) :: DropType -> DropType -> Bool

(/=) :: DropType -> DropType -> Bool

Data DropType

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

Methods

showsPrec :: Int -> DropType -> ShowS

show :: DropType -> String

showList :: [DropType] -> ShowS

data Cascade

Constructors

Cascade

Restrict

Instances

Eq Cascade

Methods

(==) :: Cascade -> Cascade -> Bool

(/=) :: Cascade -> Cascade -> Bool

Data Cascade

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

Methods

showsPrec :: Int -> Cascade -> ShowS

show :: Cascade -> String

showList :: [Cascade] -> ShowS

data IfExists

Constructors

Require

IfExists

Instances

Eq IfExists

Methods

(==) :: IfExists -> IfExists -> Bool

(/=) :: IfExists -> IfExists -> Bool

Data IfExists

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

Methods

showsPrec :: Int -> IfExists -> ShowS

show :: IfExists -> String

showList :: [IfExists] -> ShowS

data RestartIdentity

Constructors

RestartIdentity

ContinueIdentity

Instances

Eq RestartIdentity

Methods

(==) :: RestartIdentity -> RestartIdentity -> Bool

(/=) :: RestartIdentity -> RestartIdentity -> Bool

Data RestartIdentity

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

Methods

showsPrec :: Int -> RestartIdentity -> ShowS

show :: RestartIdentity -> String

showList :: [RestartIdentity] -> ShowS

function ddl components

data Replace

Constructors

Replace

NoReplace

Instances

Eq Replace

Methods

(==) :: Replace -> Replace -> Bool

(/=) :: Replace -> Replace -> Bool

Data Replace

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

Methods

showsPrec :: Int -> Replace -> ShowS

show :: Replace -> String

showList :: [Replace] -> ShowS

data Volatility

Constructors

Volatile

Stable

Immutable

Instances

Eq Volatility

Methods

(==) :: Volatility -> Volatility -> Bool

(/=) :: Volatility -> Volatility -> Bool

Data Volatility

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

Methods

showsPrec :: Int -> Volatility -> ShowS

show :: Volatility -> String

showList :: [Volatility] -> ShowS

data Language

Constructors

Sql

Plpgsql

Instances

Eq Language

Methods

(==) :: Language -> Language -> Bool

(/=) :: Language -> Language -> Bool

Data Language

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

Methods

showsPrec :: Int -> Language -> ShowS

show :: Language -> String

showList :: [Language] -> ShowS

data FnBody

Constructors

SqlFnBody Annotation StatementList

PlpgsqlFnBody Annotation Statement

Instances

Eq FnBody

Methods

(==) :: FnBody -> FnBody -> Bool

(/=) :: FnBody -> FnBody -> Bool

Data FnBody

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

Methods

showsPrec :: Int -> FnBody -> ShowS

show :: FnBody -> String

showList :: [FnBody] -> ShowS

PlPgsql components

data ParamDef

Constructors

ParamDef Annotation NameComponent TypeName

ParamDefTp Annotation TypeName

Instances

Eq ParamDef

Methods

(==) :: ParamDef -> ParamDef -> Bool

(/=) :: ParamDef -> ParamDef -> Bool

Data ParamDef

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

Methods

showsPrec :: Int -> ParamDef -> ShowS

show :: ParamDef -> String

showList :: [ParamDef] -> ShowS

data VarDef

Constructors

VarDef Annotation NameComponent TypeName (Maybe ScalarExpr)

ParamAlias Annotation NameComponent Integer

VarAlias Annotation NameComponent Name

Instances

Eq VarDef

Methods

(==) :: VarDef -> VarDef -> Bool

(/=) :: VarDef -> VarDef -> Bool

Data VarDef

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

Methods

showsPrec :: Int -> VarDef -> ShowS

show :: VarDef -> String

showList :: [VarDef] -> ShowS

data RaiseType

Constructors

RNotice

RException

RError

Instances

Eq RaiseType

Methods

(==) :: RaiseType -> RaiseType -> Bool

(/=) :: RaiseType -> RaiseType -> Bool

Data RaiseType

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

Methods

showsPrec :: Int -> RaiseType -> ShowS

show :: RaiseType -> String

showList :: [RaiseType] -> ShowS

utility

data SetValue

Constructors

SetStr Annotation String

SetId Annotation String

SetNum Annotation Double

Instances

Eq SetValue

Methods

(==) :: SetValue -> SetValue -> Bool

(/=) :: SetValue -> SetValue -> Bool

Data SetValue

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

Methods

showsPrec :: Int -> SetValue -> ShowS

show :: SetValue -> String

showList :: [SetValue] -> ShowS

misc