simple-sql-parser-0.6.0: A parser for SQL.

Safe HaskellSafe
LanguageHaskell2010

Language.SQL.SimpleSQL.Syntax

Contents

Description

The AST for SQL.

Synopsis

Scalar expressions

data ScalarExpr 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 String

string literal, with the start and end quote e.g. test -> StringLit "'" "'" "test"

IntervalLit

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

Fields

TypedLit TypeName String

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

Iden [Name]

identifier with parts separated by dots

Star

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

Parameter

Represents a ? in a parameterized query

PositionalArg Int

Represents an e.g. $1 in a parameterized query

HostParameter String (Maybe String)

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

BinOp ScalarExpr [Name] ScalarExpr

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] ScalarExpr

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

PostfixOp [Name] ScalarExpr

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

SpecialOp [Name] [ScalarExpr]

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

App [Name] [ScalarExpr]

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

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

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.

Cast ScalarExpr TypeName

cast(a as typename)

Case

case expression. both flavours supported

Fields

Parens ScalarExpr 
In Bool ScalarExpr InPredValue

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

SubQueryExpr SubQueryExprType QueryExpr

exists, all, any, some subqueries

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

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

ArrayCtor QueryExpr

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

Collate ScalarExpr [Name] 
MultisetBinOp ScalarExpr SetOperatorName SetQuantifier ScalarExpr 
MultisetCtor [ScalarExpr] 
MultisetQueryCtor QueryExpr 
NextValueFor [Name] 
VEComment [Comment] ScalarExpr 
OdbcLiteral OdbcLiteralType String

an odbc literal e.g. {d '2000-01-01'}

OdbcFunc ScalarExpr

an odbc function call e.g. {fn CHARACTER_LENGTH(test)}

Instances
Eq ScalarExpr Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data ScalarExpr Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 #

Read ScalarExpr Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show ScalarExpr Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data Name Source #

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

  • test -> Name Nothing "test"
  • "test" -> Name (Just """,""") "test"
  • something -> Name (Just ("`","`") "something"
  • [ms] -> Name (Just ("[","]") "ms"

Constructors

Name (Maybe (String, String)) String 
Instances
Eq Name Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data Name Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show Name Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data TypeName Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show TypeName Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data IntervalTypeField Source #

Constructors

Itf String (Maybe (Integer, Maybe Integer)) 
Instances
Eq IntervalTypeField Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data IntervalTypeField Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show IntervalTypeField Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data Sign Source #

Constructors

Plus 
Minus 
Instances
Eq Sign Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data Sign Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: Sign -> Constr #

dataTypeOf :: Sign -> DataType #

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

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

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

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

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

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

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

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

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

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

Read Sign Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show Sign Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> Sign -> ShowS #

show :: Sign -> String #

showList :: [Sign] -> ShowS #

data PrecMultiplier Source #

Constructors

PrecK 
PrecM 
PrecG 
PrecT 
PrecP 
Instances
Eq PrecMultiplier Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data PrecMultiplier Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show PrecMultiplier Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data PrecUnits Source #

Constructors

PrecCharacters 
PrecOctets 
Instances
Eq PrecUnits Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data PrecUnits Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show PrecUnits Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data SetQuantifier Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show SetQuantifier Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data SortSpec Source #

Represents one field in an order by list.

Instances
Eq SortSpec Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data SortSpec Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show SortSpec Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data Direction Source #

The direction for a column in order by.

Constructors

DirDefault 
Asc 
Desc 
Instances
Eq Direction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data Direction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show Direction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data NullsOrder Source #

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

Instances
Eq NullsOrder Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data NullsOrder Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show NullsOrder Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data InPredValue Source #

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

Instances
Eq InPredValue Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data InPredValue Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show InPredValue Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data SubQueryExprType Source #

A subquery in a scalar expression.

Constructors

SqExists

exists (query expr)

SqUnique

unique (query expr)

SqSq

a scalar subquery

Instances
Eq SubQueryExprType Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data SubQueryExprType Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show SubQueryExprType Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data CompPredQuantifier Source #

Constructors

CPAny 
CPSome 
CPAll 
Instances
Eq CompPredQuantifier Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data CompPredQuantifier Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show CompPredQuantifier Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data Frame Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show Frame Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data FrameRows Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show FrameRows Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data FramePos Source #

represents the start or end of a frame

Instances
Eq FramePos Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data FramePos Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show FramePos Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data OdbcLiteralType Source #

the type of an odbc literal (e.g. {d '2000-01-01'}), correpsonding to the letter after the opening {

Constructors

OLDate 
OLTime 
OLTimestamp 
Instances
Eq OdbcLiteralType Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data OdbcLiteralType Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 #

Read OdbcLiteralType Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show OdbcLiteralType Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data QueryExpr Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show QueryExpr Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 SetOperatorName Source #

Query expression set operators.

Constructors

Union 
Except 
Intersect 
Instances
Eq SetOperatorName Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data SetOperatorName Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: SetOperatorName -> Constr #

dataTypeOf :: SetOperatorName -> DataType #

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

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

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

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

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

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

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

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

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

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

Read SetOperatorName Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show SetOperatorName Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data Corresponding Source #

Corresponding, an option for the set operators.

Instances
Eq Corresponding Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data Corresponding Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show Corresponding Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data Alias Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show Alias Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data GroupingExpr Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show GroupingExpr Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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] [ScalarExpr]

from function(args)

TRLateral TableRef

from lateral t

TROdbc TableRef

ODBC {oj t1 left outer join t2 on expr} syntax

Instances
Eq TableRef Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data TableRef Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show TableRef Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data JoinType Source #

The type of a join.

Constructors

JInner 
JLeft 
JRight 
JFull 
JCross 
Instances
Eq JoinType Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data JoinType Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show JoinType Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data JoinCondition Source #

The join condition.

Constructors

JoinOn ScalarExpr

on expr

JoinUsing [Name]

using (column list)

Instances
Eq JoinCondition Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data JoinCondition Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show JoinCondition Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Statements

data Statement Source #

Instances
Eq Statement Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data Statement Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 #

Read Statement Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show Statement Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data DropBehaviour Source #

Instances
Eq DropBehaviour Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data DropBehaviour Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: DropBehaviour -> Constr #

dataTypeOf :: DropBehaviour -> DataType #

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

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

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

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

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

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

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

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

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

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

Read DropBehaviour Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show DropBehaviour Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data IdentityRestart Source #

Instances
Eq IdentityRestart Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data IdentityRestart Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: IdentityRestart -> Constr #

dataTypeOf :: IdentityRestart -> DataType #

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

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

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

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

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

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

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

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

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

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

Read IdentityRestart Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show IdentityRestart Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data InsertSource Source #

Instances
Eq InsertSource Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data InsertSource Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: InsertSource -> Constr #

dataTypeOf :: InsertSource -> DataType #

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

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

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

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

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

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

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

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

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

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

Read InsertSource Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show InsertSource Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data SetClause Source #

Constructors

Set [Name] ScalarExpr 
SetMultiple [[Name]] [ScalarExpr] 
Instances
Eq SetClause Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data SetClause Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 #

Read SetClause Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show SetClause Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data TableElement Source #

Instances
Eq TableElement Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data TableElement Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: TableElement -> Constr #

dataTypeOf :: TableElement -> DataType #

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

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

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

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

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

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

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

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

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

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

Read TableElement Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show TableElement Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data ColumnDef Source #

Instances
Eq ColumnDef Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data ColumnDef Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: ColumnDef -> Constr #

dataTypeOf :: ColumnDef -> DataType #

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

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

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

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

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

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

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

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

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

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

Read ColumnDef Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show ColumnDef Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data DefaultClause Source #

Instances
Eq DefaultClause Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data DefaultClause Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: DefaultClause -> Constr #

dataTypeOf :: DefaultClause -> DataType #

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

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

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

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

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

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

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

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

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

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

Read DefaultClause Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show DefaultClause Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data IdentityWhen Source #

Instances
Eq IdentityWhen Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data IdentityWhen Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: IdentityWhen -> Constr #

dataTypeOf :: IdentityWhen -> DataType #

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

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

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

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

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

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

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

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

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

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

Read IdentityWhen Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show IdentityWhen Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data SequenceGeneratorOption Source #

Instances
Eq SequenceGeneratorOption Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data SequenceGeneratorOption Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: SequenceGeneratorOption -> Constr #

dataTypeOf :: SequenceGeneratorOption -> DataType #

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

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

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

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

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

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

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

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

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

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

Read SequenceGeneratorOption Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show SequenceGeneratorOption Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data ColConstraintDef Source #

Instances
Eq ColConstraintDef Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data ColConstraintDef Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: ColConstraintDef -> Constr #

dataTypeOf :: ColConstraintDef -> DataType #

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

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

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

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

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

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

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

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

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

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

Read ColConstraintDef Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show ColConstraintDef Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data ColConstraint Source #

Instances
Eq ColConstraint Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data ColConstraint Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: ColConstraint -> Constr #

dataTypeOf :: ColConstraint -> DataType #

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

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

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

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

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

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

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

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

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

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

Read ColConstraint Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show ColConstraint Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data TableConstraint Source #

Instances
Eq TableConstraint Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data TableConstraint Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: TableConstraint -> Constr #

dataTypeOf :: TableConstraint -> DataType #

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

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

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

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

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

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

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

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

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

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

Read TableConstraint Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show TableConstraint Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data ReferenceMatch Source #

Instances
Eq ReferenceMatch Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data ReferenceMatch Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: ReferenceMatch -> Constr #

dataTypeOf :: ReferenceMatch -> DataType #

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

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

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

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

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

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

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

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

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

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

Read ReferenceMatch Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show ReferenceMatch Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data ReferentialAction Source #

Instances
Eq ReferentialAction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data ReferentialAction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: ReferentialAction -> Constr #

dataTypeOf :: ReferentialAction -> DataType #

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

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

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

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

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

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

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

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

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

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

Read ReferentialAction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show ReferentialAction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data AlterTableAction Source #

Instances
Eq AlterTableAction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data AlterTableAction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 #

Read AlterTableAction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show AlterTableAction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data CheckOption Source #

Instances
Eq CheckOption Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data CheckOption Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: CheckOption -> Constr #

dataTypeOf :: CheckOption -> DataType #

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

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

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

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

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

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

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

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

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

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

Read CheckOption Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show CheckOption Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data AlterDomainAction Source #

Instances
Eq AlterDomainAction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data AlterDomainAction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: AlterDomainAction -> Constr #

dataTypeOf :: AlterDomainAction -> DataType #

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

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

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

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

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

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

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

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

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

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

Read AlterDomainAction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show AlterDomainAction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data AdminOption Source #

Instances
Eq AdminOption Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data AdminOption Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: AdminOption -> Constr #

dataTypeOf :: AdminOption -> DataType #

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

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

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

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

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

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

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

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

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

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

Read AdminOption Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show AdminOption Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data GrantOption Source #

Instances
Eq GrantOption Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data GrantOption Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: GrantOption -> Constr #

dataTypeOf :: GrantOption -> DataType #

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

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

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

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

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

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

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

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

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

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

Read GrantOption Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show GrantOption Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data PrivilegeObject Source #

Instances
Eq PrivilegeObject Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data PrivilegeObject Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: PrivilegeObject -> Constr #

dataTypeOf :: PrivilegeObject -> DataType #

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

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

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

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

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

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

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

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

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

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

Read PrivilegeObject Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show PrivilegeObject Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data PrivilegeAction Source #

Instances
Eq PrivilegeAction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data PrivilegeAction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: PrivilegeAction -> Constr #

dataTypeOf :: PrivilegeAction -> DataType #

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

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

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

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

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

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

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

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

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

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

Read PrivilegeAction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show PrivilegeAction Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data AdminOptionFor Source #

Instances
Eq AdminOptionFor Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data AdminOptionFor Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: AdminOptionFor -> Constr #

dataTypeOf :: AdminOptionFor -> DataType #

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

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

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

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

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

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

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

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

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

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

Read AdminOptionFor Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show AdminOptionFor Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

data GrantOptionFor Source #

Instances
Eq GrantOptionFor Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Data GrantOptionFor Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: GrantOptionFor -> Constr #

dataTypeOf :: GrantOptionFor -> DataType #

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

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

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

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

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

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

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

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

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

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

Read GrantOptionFor Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show GrantOptionFor Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Comment

data Comment Source #

Comment. Useful when generating SQL code programmatically. The parser doesn't produce these.

Constructors

BlockComment String 
Instances
Eq Comment Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data Comment Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

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 # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax

Show Comment Source # 
Instance details

Defined in Language.SQL.SimpleSQL.Syntax