simple-sql-parser-0.4.3: A parser for SQL queries

Safe HaskellSafe
LanguageHaskell2010

Language.SQL.SimpleSQL.Syntax

Contents

Description

The AST for SQL queries.

Synopsis

Value expressions

data ValueExpr Source #

Represents a value expression. This is used for the expressions in select lists. It is also used for expressions in where, group by, having, order by and so on.

Constructors

NumLit String

a numeric literal optional decimal point, e+- integral exponent, e.g

  • 10
  • 10.
  • .1
  • 10.1
  • 1e5
  • 12.34e-6
StringLit String

string literal, currently only basic strings between single quotes with a single quote escaped using ''

IntervalLit

text of interval literal, units of interval precision, e.g. interval 3 days (3)

Fields

Iden [Name]

identifier with parts separated by dots

Star

star, as in select *, t.*, count(*)

App [Name] [ValueExpr]

function application (anything that looks like c style function application syntactically)

AggregateApp

aggregate application, which adds distinct or all, and order by, to regular function application

Fields

AggregateAppGroup

aggregates with within group

Fields

WindowApp

window application, which adds over (partition by a order by b) to regular function application. Explicit frames are not currently supported

Fields

BinOp ValueExpr [Name] ValueExpr

Infix binary operators. This is used for symbol operators (a + b), keyword operators (a and b) and multiple keyword operators (a is similar to b)

PrefixOp [Name] ValueExpr

Prefix unary operators. This is used for symbol operators, keyword operators and multiple keyword operators.

PostfixOp [Name] ValueExpr

Postfix unary operators. This is used for symbol operators, keyword operators and multiple keyword operators.

SpecialOp [Name] [ValueExpr]

Used for ternary, mixfix and other non orthodox operators. Currently used for row constructors, and for between.

SpecialOpK [Name] (Maybe ValueExpr) [(String, ValueExpr)]

Used for the operators which look like functions except the arguments are separated by keywords instead of commas. The maybe is for the first unnamed argument if it is present, and the list is for the keyword argument pairs.

Case

case expression. both flavours supported

Fields

Parens ValueExpr 
Cast ValueExpr TypeName

cast(a as typename)

TypedLit TypeName String

prefix 'typed literal', e.g. int '42'

SubQueryExpr SubQueryExprType QueryExpr

exists, all, any, some subqueries

In Bool ValueExpr InPredValue

in list literal and in subquery, if the bool is false it means not in was used ('a not in (1,2)')

Parameter

Represents a ? in a parameterized query

HostParameter String (Maybe String)

represents a host parameter, e.g. :a. The Maybe String is for the indicator, e.g. :var indicator :nl

QuantifiedComparison ValueExpr [Name] CompPredQuantifier QueryExpr 
Match ValueExpr Bool QueryExpr 
Array ValueExpr [ValueExpr]

represents an array access expression, or an array ctor e.g. a[3]. The first valueExpr is the array, the second is the subscripts/ctor args

ArrayCtor QueryExpr

this is used for the query expression version of array constructors, e.g. array(select * from t)

CSStringLit String String 
Escape ValueExpr Char 
UEscape ValueExpr Char 
Collate ValueExpr [Name] 
MultisetBinOp ValueExpr CombineOp SetQuantifier ValueExpr 
MultisetCtor [ValueExpr] 
MultisetQueryCtor QueryExpr 
NextValueFor [Name] 
VEComment [Comment] ValueExpr 

Instances

Eq ValueExpr Source # 
Data ValueExpr Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ValueExpr -> c ValueExpr #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ValueExpr #

toConstr :: ValueExpr -> Constr #

dataTypeOf :: ValueExpr -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ValueExpr) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ValueExpr) #

gmapT :: (forall b. Data b => b -> b) -> ValueExpr -> ValueExpr #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ValueExpr -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ValueExpr -> r #

gmapQ :: (forall d. Data d => d -> u) -> ValueExpr -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ValueExpr -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ValueExpr -> m ValueExpr #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ValueExpr -> m ValueExpr #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ValueExpr -> m ValueExpr #

Read ValueExpr Source # 
Show ValueExpr Source # 

data Name Source #

Represents an identifier name, which can be quoted or unquoted.

Constructors

Name String 
QName String 
UQName String 
DQName String String String

dialect quoted name, the fields are start quote, end quote and the string itself, e.g. something is parsed to DQName "`" "`" "something, and $a$ test $a$ is parsed to DQName "$a$" "$a" " test "

Instances

Eq Name Source # 

Methods

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

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

Data Name Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name #

toConstr :: Name -> Constr #

dataTypeOf :: Name -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Name) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) #

gmapT :: (forall b. Data b => b -> b) -> Name -> Name #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r #

gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name #

Read Name Source # 
Show Name Source # 

Methods

showsPrec :: Int -> Name -> ShowS #

show :: Name -> String #

showList :: [Name] -> ShowS #

data TypeName Source #

Represents a type name, used in casts.

Instances

Eq TypeName Source # 
Data TypeName Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeName -> c TypeName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeName #

toConstr :: TypeName -> Constr #

dataTypeOf :: TypeName -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TypeName) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeName) #

gmapT :: (forall b. Data b => b -> b) -> TypeName -> TypeName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeName -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeName -> r #

gmapQ :: (forall d. Data d => d -> u) -> TypeName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeName -> m TypeName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeName -> m TypeName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeName -> m TypeName #

Read TypeName Source # 
Show TypeName Source # 

data IntervalTypeField Source #

Constructors

Itf String (Maybe (Integer, Maybe Integer)) 

Instances

Eq IntervalTypeField Source # 
Data IntervalTypeField Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntervalTypeField -> c IntervalTypeField #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IntervalTypeField #

toConstr :: IntervalTypeField -> Constr #

dataTypeOf :: IntervalTypeField -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c IntervalTypeField) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IntervalTypeField) #

gmapT :: (forall b. Data b => b -> b) -> IntervalTypeField -> IntervalTypeField #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntervalTypeField -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntervalTypeField -> r #

gmapQ :: (forall d. Data d => d -> u) -> IntervalTypeField -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IntervalTypeField -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IntervalTypeField -> m IntervalTypeField #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IntervalTypeField -> m IntervalTypeField #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IntervalTypeField -> m IntervalTypeField #

Read IntervalTypeField Source # 
Show IntervalTypeField Source # 

data PrecMultiplier Source #

Constructors

PrecK 
PrecM 
PrecG 
PrecT 
PrecP 

Instances

Eq PrecMultiplier Source # 
Data PrecMultiplier Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PrecMultiplier -> c PrecMultiplier #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PrecMultiplier #

toConstr :: PrecMultiplier -> Constr #

dataTypeOf :: PrecMultiplier -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PrecMultiplier) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrecMultiplier) #

gmapT :: (forall b. Data b => b -> b) -> PrecMultiplier -> PrecMultiplier #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PrecMultiplier -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PrecMultiplier -> r #

gmapQ :: (forall d. Data d => d -> u) -> PrecMultiplier -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PrecMultiplier -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PrecMultiplier -> m PrecMultiplier #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PrecMultiplier -> m PrecMultiplier #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PrecMultiplier -> m PrecMultiplier #

Read PrecMultiplier Source # 
Show PrecMultiplier Source # 

data PrecUnits Source #

Constructors

PrecCharacters 
PrecOctets 

Instances

Eq PrecUnits Source # 
Data PrecUnits Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PrecUnits -> c PrecUnits #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PrecUnits #

toConstr :: PrecUnits -> Constr #

dataTypeOf :: PrecUnits -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PrecUnits) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrecUnits) #

gmapT :: (forall b. Data b => b -> b) -> PrecUnits -> PrecUnits #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PrecUnits -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PrecUnits -> r #

gmapQ :: (forall d. Data d => d -> u) -> PrecUnits -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PrecUnits -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits #

Read PrecUnits Source # 
Show PrecUnits Source # 

data SetQuantifier Source #

Represents the Distinct or All keywords, which can be used before a select list, in an aggregate/window function application, or in a query expression set operator.

Constructors

SQDefault 
Distinct 
All 

Instances

Eq SetQuantifier Source # 
Data SetQuantifier Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SetQuantifier -> c SetQuantifier #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SetQuantifier #

toConstr :: SetQuantifier -> Constr #

dataTypeOf :: SetQuantifier -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SetQuantifier) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SetQuantifier) #

gmapT :: (forall b. Data b => b -> b) -> SetQuantifier -> SetQuantifier #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SetQuantifier -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SetQuantifier -> r #

gmapQ :: (forall d. Data d => d -> u) -> SetQuantifier -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SetQuantifier -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier #

Read SetQuantifier Source # 
Show SetQuantifier Source # 

data SortSpec Source #

Represents one field in an order by list.

Instances

Eq SortSpec Source # 
Data SortSpec Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SortSpec -> c SortSpec #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SortSpec #

toConstr :: SortSpec -> Constr #

dataTypeOf :: SortSpec -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SortSpec) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SortSpec) #

gmapT :: (forall b. Data b => b -> b) -> SortSpec -> SortSpec #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SortSpec -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SortSpec -> r #

gmapQ :: (forall d. Data d => d -> u) -> SortSpec -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SortSpec -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SortSpec -> m SortSpec #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SortSpec -> m SortSpec #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SortSpec -> m SortSpec #

Read SortSpec Source # 
Show SortSpec Source # 

data Direction Source #

The direction for a column in order by.

Constructors

DirDefault 
Asc 
Desc 

Instances

Eq Direction Source # 
Data Direction Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Direction -> c Direction #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Direction #

toConstr :: Direction -> Constr #

dataTypeOf :: Direction -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Direction) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Direction) #

gmapT :: (forall b. Data b => b -> b) -> Direction -> Direction #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Direction -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Direction -> r #

gmapQ :: (forall d. Data d => d -> u) -> Direction -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Direction -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Direction -> m Direction #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Direction -> m Direction #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Direction -> m Direction #

Read Direction Source # 
Show Direction Source # 

data NullsOrder Source #

Represents 'nulls first' or 'nulls last' in an order by clause.

Instances

Eq NullsOrder Source # 
Data NullsOrder Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NullsOrder -> c NullsOrder #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NullsOrder #

toConstr :: NullsOrder -> Constr #

dataTypeOf :: NullsOrder -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c NullsOrder) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NullsOrder) #

gmapT :: (forall b. Data b => b -> b) -> NullsOrder -> NullsOrder #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NullsOrder -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NullsOrder -> r #

gmapQ :: (forall d. Data d => d -> u) -> NullsOrder -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NullsOrder -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder #

Read NullsOrder Source # 
Show NullsOrder Source # 

data InPredValue Source #

Used for 'expr in (value expression list)', and 'expr in (subquery)' syntax.

Instances

Eq InPredValue Source # 
Data InPredValue Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InPredValue -> c InPredValue #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InPredValue #

toConstr :: InPredValue -> Constr #

dataTypeOf :: InPredValue -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c InPredValue) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InPredValue) #

gmapT :: (forall b. Data b => b -> b) -> InPredValue -> InPredValue #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InPredValue -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InPredValue -> r #

gmapQ :: (forall d. Data d => d -> u) -> InPredValue -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> InPredValue -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InPredValue -> m InPredValue #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InPredValue -> m InPredValue #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InPredValue -> m InPredValue #

Read InPredValue Source # 
Show InPredValue Source # 

data SubQueryExprType Source #

A subquery in a value expression.

Constructors

SqExists

exists (query expr)

SqUnique

unique (query expr)

SqSq

a scalar subquery

Instances

Eq SubQueryExprType Source # 
Data SubQueryExprType Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SubQueryExprType -> c SubQueryExprType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SubQueryExprType #

toConstr :: SubQueryExprType -> Constr #

dataTypeOf :: SubQueryExprType -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SubQueryExprType) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubQueryExprType) #

gmapT :: (forall b. Data b => b -> b) -> SubQueryExprType -> SubQueryExprType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SubQueryExprType -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SubQueryExprType -> r #

gmapQ :: (forall d. Data d => d -> u) -> SubQueryExprType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SubQueryExprType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SubQueryExprType -> m SubQueryExprType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SubQueryExprType -> m SubQueryExprType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SubQueryExprType -> m SubQueryExprType #

Read SubQueryExprType Source # 
Show SubQueryExprType Source # 

data CompPredQuantifier Source #

Constructors

CPAny 
CPSome 
CPAll 

Instances

Eq CompPredQuantifier Source # 
Data CompPredQuantifier Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CompPredQuantifier -> c CompPredQuantifier #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CompPredQuantifier #

toConstr :: CompPredQuantifier -> Constr #

dataTypeOf :: CompPredQuantifier -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c CompPredQuantifier) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompPredQuantifier) #

gmapT :: (forall b. Data b => b -> b) -> CompPredQuantifier -> CompPredQuantifier #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CompPredQuantifier -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CompPredQuantifier -> r #

gmapQ :: (forall d. Data d => d -> u) -> CompPredQuantifier -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CompPredQuantifier -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CompPredQuantifier -> m CompPredQuantifier #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CompPredQuantifier -> m CompPredQuantifier #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CompPredQuantifier -> m CompPredQuantifier #

Read CompPredQuantifier Source # 
Show CompPredQuantifier Source # 

data Frame Source #

Represents the frame clause of a window this can be [range | rows] frame_start or [range | rows] between frame_start and frame_end

Instances

Eq Frame Source # 

Methods

(==) :: Frame -> Frame -> Bool #

(/=) :: Frame -> Frame -> Bool #

Data Frame Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Frame -> c Frame #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Frame #

toConstr :: Frame -> Constr #

dataTypeOf :: Frame -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Frame) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Frame) #

gmapT :: (forall b. Data b => b -> b) -> Frame -> Frame #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Frame -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Frame -> r #

gmapQ :: (forall d. Data d => d -> u) -> Frame -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Frame -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Frame -> m Frame #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Frame -> m Frame #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Frame -> m Frame #

Read Frame Source # 
Show Frame Source # 

Methods

showsPrec :: Int -> Frame -> ShowS #

show :: Frame -> String #

showList :: [Frame] -> ShowS #

data FrameRows Source #

Represents whether a window frame clause is over rows or ranges.

Constructors

FrameRows 
FrameRange 

Instances

Eq FrameRows Source # 
Data FrameRows Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FrameRows -> c FrameRows #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FrameRows #

toConstr :: FrameRows -> Constr #

dataTypeOf :: FrameRows -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FrameRows) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FrameRows) #

gmapT :: (forall b. Data b => b -> b) -> FrameRows -> FrameRows #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FrameRows -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FrameRows -> r #

gmapQ :: (forall d. Data d => d -> u) -> FrameRows -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FrameRows -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FrameRows -> m FrameRows #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FrameRows -> m FrameRows #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FrameRows -> m FrameRows #

Read FrameRows Source # 
Show FrameRows Source # 

data FramePos Source #

represents the start or end of a frame

Instances

Eq FramePos Source # 
Data FramePos Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FramePos -> c FramePos #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FramePos #

toConstr :: FramePos -> Constr #

dataTypeOf :: FramePos -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FramePos) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FramePos) #

gmapT :: (forall b. Data b => b -> b) -> FramePos -> FramePos #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FramePos -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FramePos -> r #

gmapQ :: (forall d. Data d => d -> u) -> FramePos -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FramePos -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FramePos -> m FramePos #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FramePos -> m FramePos #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FramePos -> m FramePos #

Read FramePos Source # 
Show FramePos Source # 

Query expressions

data QueryExpr Source #

Represents a query expression, which can be:

  • a regular select;
  • a set operator (union, except, intersect);
  • a common table expression (with);
  • a table value constructor (values (1,2),(3,4)); or
  • an explicit table (table t).

Instances

Eq QueryExpr Source # 
Data QueryExpr Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QueryExpr -> c QueryExpr #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c QueryExpr #

toConstr :: QueryExpr -> Constr #

dataTypeOf :: QueryExpr -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c QueryExpr) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QueryExpr) #

gmapT :: (forall b. Data b => b -> b) -> QueryExpr -> QueryExpr #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QueryExpr -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QueryExpr -> r #

gmapQ :: (forall d. Data d => d -> u) -> QueryExpr -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> QueryExpr -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr #

Read QueryExpr Source # 
Show QueryExpr Source # 

makeSelect :: QueryExpr Source #

Helper/'default' value for query exprs to make creating query expr values a little easier. It is defined like this:

makeSelect :: QueryExpr
makeSelect = Select {qeSetQuantifier = SQDefault
                    ,qeSelectList = []
                    ,qeFrom = []
                    ,qeWhere = Nothing
                    ,qeGroupBy = []
                    ,qeHaving = Nothing
                    ,qeOrderBy = []
                    ,qeOffset = Nothing
                    ,qeFetchFirst = Nothing}

data CombineOp Source #

Query expression set operators.

Constructors

Union 
Except 
Intersect 

Instances

Eq CombineOp Source # 
Data CombineOp Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CombineOp -> c CombineOp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CombineOp #

toConstr :: CombineOp -> Constr #

dataTypeOf :: CombineOp -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c CombineOp) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CombineOp) #

gmapT :: (forall b. Data b => b -> b) -> CombineOp -> CombineOp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CombineOp -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CombineOp -> r #

gmapQ :: (forall d. Data d => d -> u) -> CombineOp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CombineOp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CombineOp -> m CombineOp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CombineOp -> m CombineOp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CombineOp -> m CombineOp #

Read CombineOp Source # 
Show CombineOp Source # 

data Corresponding Source #

Corresponding, an option for the set operators.

Instances

Eq Corresponding Source # 
Data Corresponding Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Corresponding -> c Corresponding #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Corresponding #

toConstr :: Corresponding -> Constr #

dataTypeOf :: Corresponding -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Corresponding) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Corresponding) #

gmapT :: (forall b. Data b => b -> b) -> Corresponding -> Corresponding #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Corresponding -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Corresponding -> r #

gmapQ :: (forall d. Data d => d -> u) -> Corresponding -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Corresponding -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Corresponding -> m Corresponding #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Corresponding -> m Corresponding #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Corresponding -> m Corresponding #

Read Corresponding Source # 
Show Corresponding Source # 

data Alias Source #

Represents an alias for a table valued expression, used in with queries and in from alias, e.g. select a from t u, select a from t u(b), with a(c) as select 1, select * from a.

Constructors

Alias Name (Maybe [Name]) 

Instances

Eq Alias Source # 

Methods

(==) :: Alias -> Alias -> Bool #

(/=) :: Alias -> Alias -> Bool #

Data Alias Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Alias -> c Alias #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Alias #

toConstr :: Alias -> Constr #

dataTypeOf :: Alias -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Alias) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alias) #

gmapT :: (forall b. Data b => b -> b) -> Alias -> Alias #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alias -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alias -> r #

gmapQ :: (forall d. Data d => d -> u) -> Alias -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Alias -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alias -> m Alias #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alias -> m Alias #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alias -> m Alias #

Read Alias Source # 
Show Alias Source # 

Methods

showsPrec :: Int -> Alias -> ShowS #

show :: Alias -> String #

showList :: [Alias] -> ShowS #

data GroupingExpr Source #

Represents an item in a group by clause.

Instances

Eq GroupingExpr Source # 
Data GroupingExpr Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GroupingExpr -> c GroupingExpr #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c GroupingExpr #

toConstr :: GroupingExpr -> Constr #

dataTypeOf :: GroupingExpr -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c GroupingExpr) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GroupingExpr) #

gmapT :: (forall b. Data b => b -> b) -> GroupingExpr -> GroupingExpr #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GroupingExpr -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GroupingExpr -> r #

gmapQ :: (forall d. Data d => d -> u) -> GroupingExpr -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> GroupingExpr -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr #

Read GroupingExpr Source # 
Show GroupingExpr Source # 

From

data TableRef Source #

Represents a entry in the csv of tables in the from clause.

Constructors

TRSimple [Name]

from t / from s.t

TRJoin TableRef Bool JoinType TableRef (Maybe JoinCondition)

from a join b, the bool is true if natural was used

TRParens TableRef

from (a)

TRAlias TableRef Alias

from a as b(c,d)

TRQueryExpr QueryExpr

from (query expr)

TRFunction [Name] [ValueExpr]

from function(args)

TRLateral TableRef

from lateral t

Instances

Eq TableRef Source # 
Data TableRef Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TableRef -> c TableRef #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TableRef #

toConstr :: TableRef -> Constr #

dataTypeOf :: TableRef -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TableRef) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableRef) #

gmapT :: (forall b. Data b => b -> b) -> TableRef -> TableRef #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TableRef -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TableRef -> r #

gmapQ :: (forall d. Data d => d -> u) -> TableRef -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TableRef -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TableRef -> m TableRef #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TableRef -> m TableRef #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TableRef -> m TableRef #

Read TableRef Source # 
Show TableRef Source # 

data JoinType Source #

The type of a join.

Constructors

JInner 
JLeft 
JRight 
JFull 
JCross 

Instances

Eq JoinType Source # 
Data JoinType Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JoinType -> c JoinType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c JoinType #

toConstr :: JoinType -> Constr #

dataTypeOf :: JoinType -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c JoinType) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinType) #

gmapT :: (forall b. Data b => b -> b) -> JoinType -> JoinType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> JoinType -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> JoinType -> r #

gmapQ :: (forall d. Data d => d -> u) -> JoinType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> JoinType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> JoinType -> m JoinType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinType -> m JoinType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinType -> m JoinType #

Read JoinType Source # 
Show JoinType Source # 

data JoinCondition Source #

The join condition.

Constructors

JoinOn ValueExpr

on expr

JoinUsing [Name]

using (column list)

Instances

Eq JoinCondition Source # 
Data JoinCondition Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JoinCondition -> c JoinCondition #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c JoinCondition #

toConstr :: JoinCondition -> Constr #

dataTypeOf :: JoinCondition -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c JoinCondition) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinCondition) #

gmapT :: (forall b. Data b => b -> b) -> JoinCondition -> JoinCondition #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> JoinCondition -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> JoinCondition -> r #

gmapQ :: (forall d. Data d => d -> u) -> JoinCondition -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> JoinCondition -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition #

Read JoinCondition Source # 
Show JoinCondition Source # 

dialect

data Dialect Source #

Used to set the dialect used for parsing and pretty printing, very unfinished at the moment.

Constructors

SQL2011 
MySQL 

Instances

Eq Dialect Source # 

Methods

(==) :: Dialect -> Dialect -> Bool #

(/=) :: Dialect -> Dialect -> Bool #

Data Dialect Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dialect -> c Dialect #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Dialect #

toConstr :: Dialect -> Constr #

dataTypeOf :: Dialect -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Dialect) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dialect) #

gmapT :: (forall b. Data b => b -> b) -> Dialect -> Dialect #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dialect -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dialect -> r #

gmapQ :: (forall d. Data d => d -> u) -> Dialect -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Dialect -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dialect -> m Dialect #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dialect -> m Dialect #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dialect -> m Dialect #

Read Dialect Source # 
Show Dialect Source # 

comment

data Comment Source #

Comment. Useful when generating SQL code programmatically.

Constructors

BlockComment String 

Instances

Eq Comment Source # 

Methods

(==) :: Comment -> Comment -> Bool #

(/=) :: Comment -> Comment -> Bool #

Data Comment Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Comment -> c Comment #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Comment #

toConstr :: Comment -> Constr #

dataTypeOf :: Comment -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Comment) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Comment) #

gmapT :: (forall b. Data b => b -> b) -> Comment -> Comment #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Comment -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Comment -> r #

gmapQ :: (forall d. Data d => d -> u) -> Comment -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Comment -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Comment -> m Comment #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Comment -> m Comment #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Comment -> m Comment #

Read Comment Source # 
Show Comment Source #