Language.SQL.SimpleSQL.Syntax

The AST for SQL.

Scalar expressions

data ScalarExpr

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

• ilSign :: Maybe Sign

  if + or - used

• ilLiteral :: String

  literal text

• ilFrom :: IntervalTypeField
• ilTo :: Maybe IntervalTypeField

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

• aggName :: [Name]

  aggregate function name

• aggDistinct :: SetQuantifier

  distinct

• aggArgs :: [ScalarExpr]

  args

• aggOrderBy :: [SortSpec]

  order by

• aggFilter :: Maybe ScalarExpr

  filter

AggregateAppGroup

aggregates with within group

Fields

• aggName :: [Name]

  aggregate function name

• aggArgs :: [ScalarExpr]

  args

• aggGroup :: [SortSpec]

  within group

WindowApp

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

Fields

• wnName :: [Name]

  window function name

• wnArgs :: [ScalarExpr]

  args

• wnPartition :: [ScalarExpr]

  partition by

• wnOrderBy :: [SortSpec]

  order by

• wnFrame :: Maybe Frame

  frame clause

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

• caseTest :: Maybe ScalarExpr

  test value

• caseWhens :: [([ScalarExpr], ScalarExpr)]

  when branches

• caseElse :: Maybe ScalarExpr

  else value

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data ScalarExpr

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS ScalarExpr

readList :: ReadS [ScalarExpr]

readPrec :: ReadPrec ScalarExpr

readListPrec :: ReadPrec [ScalarExpr]

Show ScalarExpr

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> ScalarExpr -> ShowS

show :: ScalarExpr -> String

showList :: [ScalarExpr] -> ShowS

data Name

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data Name

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS Name

readList :: ReadS [Name]

readPrec :: ReadPrec Name

readListPrec :: ReadPrec [Name]

Show Name

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> Name -> ShowS

show :: Name -> String

showList :: [Name] -> ShowS

data TypeName

Represents a type name, used in casts.

Constructors

TypeName [Name]

PrecTypeName [Name] Integer

PrecScaleTypeName [Name] Integer Integer

PrecLengthTypeName [Name] Integer (Maybe PrecMultiplier) (Maybe PrecUnits)

CharTypeName [Name] (Maybe Integer) [Name] [Name]

TimeTypeName [Name] (Maybe Integer) Bool

RowTypeName [(Name, TypeName)]

IntervalTypeName IntervalTypeField (Maybe IntervalTypeField)

ArrayTypeName TypeName (Maybe Integer)

MultisetTypeName TypeName

Instances

Eq TypeName

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data TypeName

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS TypeName

readList :: ReadS [TypeName]

readPrec :: ReadPrec TypeName

readListPrec :: ReadPrec [TypeName]

Show TypeName

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> TypeName -> ShowS

show :: TypeName -> String

showList :: [TypeName] -> ShowS

data IntervalTypeField

Constructors

Itf String (Maybe (Integer, Maybe Integer))

Instances

Eq IntervalTypeField

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: IntervalTypeField -> IntervalTypeField -> Bool

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

Data IntervalTypeField

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS IntervalTypeField

readList :: ReadS [IntervalTypeField]

readPrec :: ReadPrec IntervalTypeField

readListPrec :: ReadPrec [IntervalTypeField]

Show IntervalTypeField

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> IntervalTypeField -> ShowS

show :: IntervalTypeField -> String

showList :: [IntervalTypeField] -> ShowS

data Sign

Constructors

Plus

Minus

Instances

Eq Sign

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data Sign

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS Sign

readList :: ReadS [Sign]

readPrec :: ReadPrec Sign

readListPrec :: ReadPrec [Sign]

Show Sign

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> Sign -> ShowS

show :: Sign -> String

showList :: [Sign] -> ShowS

data PrecMultiplier

Constructors

PrecK

PrecM

PrecG

PrecT

PrecP

Instances

Eq PrecMultiplier

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: PrecMultiplier -> PrecMultiplier -> Bool

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

Data PrecMultiplier

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS PrecMultiplier

readList :: ReadS [PrecMultiplier]

readPrec :: ReadPrec PrecMultiplier

readListPrec :: ReadPrec [PrecMultiplier]

Show PrecMultiplier

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> PrecMultiplier -> ShowS

show :: PrecMultiplier -> String

showList :: [PrecMultiplier] -> ShowS

data PrecUnits

Constructors

PrecCharacters

PrecOctets

Instances

Eq PrecUnits

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: PrecUnits -> PrecUnits -> Bool

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

Data PrecUnits

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS PrecUnits

readList :: ReadS [PrecUnits]

readPrec :: ReadPrec PrecUnits

readListPrec :: ReadPrec [PrecUnits]

Show PrecUnits

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> PrecUnits -> ShowS

show :: PrecUnits -> String

showList :: [PrecUnits] -> ShowS

data SetQuantifier

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: SetQuantifier -> SetQuantifier -> Bool

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

Data SetQuantifier

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS SetQuantifier

readList :: ReadS [SetQuantifier]

readPrec :: ReadPrec SetQuantifier

readListPrec :: ReadPrec [SetQuantifier]

Show SetQuantifier

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> SetQuantifier -> ShowS

show :: SetQuantifier -> String

showList :: [SetQuantifier] -> ShowS

data SortSpec

Represents one field in an order by list.

Constructors

SortSpec ScalarExpr Direction NullsOrder

Instances

Eq SortSpec

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: SortSpec -> SortSpec -> Bool

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

Data SortSpec

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS SortSpec

readList :: ReadS [SortSpec]

readPrec :: ReadPrec SortSpec

readListPrec :: ReadPrec [SortSpec]

Show SortSpec

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> SortSpec -> ShowS

show :: SortSpec -> String

showList :: [SortSpec] -> ShowS

data Direction

The direction for a column in order by.

Constructors

DirDefault

Asc

Desc

Instances

Eq Direction

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data Direction

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS Direction

readList :: ReadS [Direction]

readPrec :: ReadPrec Direction

readListPrec :: ReadPrec [Direction]

Show Direction

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> Direction -> ShowS

show :: Direction -> String

showList :: [Direction] -> ShowS

data NullsOrder

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

Constructors

NullsOrderDefault

NullsFirst

NullsLast

Instances

Eq NullsOrder

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data NullsOrder

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS NullsOrder

readList :: ReadS [NullsOrder]

readPrec :: ReadPrec NullsOrder

readListPrec :: ReadPrec [NullsOrder]

Show NullsOrder

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> NullsOrder -> ShowS

show :: NullsOrder -> String

showList :: [NullsOrder] -> ShowS

data InPredValue

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

Constructors

InList [ScalarExpr]

InQueryExpr QueryExpr

Instances

Eq InPredValue

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: InPredValue -> InPredValue -> Bool

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

Data InPredValue

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS InPredValue

readList :: ReadS [InPredValue]

readPrec :: ReadPrec InPredValue

readListPrec :: ReadPrec [InPredValue]

Show InPredValue

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> InPredValue -> ShowS

show :: InPredValue -> String

showList :: [InPredValue] -> ShowS

data SubQueryExprType

A subquery in a scalar expression.

Constructors

SqExists

exists (query expr)

SqUnique

unique (query expr)

SqSq

a scalar subquery

Instances

Eq SubQueryExprType

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: SubQueryExprType -> SubQueryExprType -> Bool

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

Data SubQueryExprType

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS SubQueryExprType

readList :: ReadS [SubQueryExprType]

readPrec :: ReadPrec SubQueryExprType

readListPrec :: ReadPrec [SubQueryExprType]

Show SubQueryExprType

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> SubQueryExprType -> ShowS

show :: SubQueryExprType -> String

showList :: [SubQueryExprType] -> ShowS

data CompPredQuantifier

Constructors

CPAny

CPSome

CPAll

Instances

Eq CompPredQuantifier

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: CompPredQuantifier -> CompPredQuantifier -> Bool

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

Data CompPredQuantifier

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS CompPredQuantifier

readList :: ReadS [CompPredQuantifier]

readPrec :: ReadPrec CompPredQuantifier

readListPrec :: ReadPrec [CompPredQuantifier]

Show CompPredQuantifier

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> CompPredQuantifier -> ShowS

show :: CompPredQuantifier -> String

showList :: [CompPredQuantifier] -> ShowS

data Frame

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

Constructors

FrameFrom FrameRows FramePos

FrameBetween FrameRows FramePos FramePos

Instances

Eq Frame

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data Frame

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS Frame

readList :: ReadS [Frame]

readPrec :: ReadPrec Frame

readListPrec :: ReadPrec [Frame]

Show Frame

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> Frame -> ShowS

show :: Frame -> String

showList :: [Frame] -> ShowS

data FrameRows

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

Constructors

FrameRows

FrameRange

Instances

Eq FrameRows

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: FrameRows -> FrameRows -> Bool

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

Data FrameRows

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS FrameRows

readList :: ReadS [FrameRows]

readPrec :: ReadPrec FrameRows

readListPrec :: ReadPrec [FrameRows]

Show FrameRows

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> FrameRows -> ShowS

show :: FrameRows -> String

showList :: [FrameRows] -> ShowS

data FramePos

represents the start or end of a frame

Constructors

UnboundedPreceding

Preceding ScalarExpr

Current

Following ScalarExpr

UnboundedFollowing

Instances

Eq FramePos

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: FramePos -> FramePos -> Bool

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

Data FramePos

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS FramePos

readList :: ReadS [FramePos]

readPrec :: ReadPrec FramePos

readListPrec :: ReadPrec [FramePos]

Show FramePos

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> FramePos -> ShowS

show :: FramePos -> String

showList :: [FramePos] -> ShowS

data OdbcLiteralType

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data OdbcLiteralType

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS OdbcLiteralType

readList :: ReadS [OdbcLiteralType]

readPrec :: ReadPrec OdbcLiteralType

readListPrec :: ReadPrec [OdbcLiteralType]

Show OdbcLiteralType

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> OdbcLiteralType -> ShowS

show :: OdbcLiteralType -> String

showList :: [OdbcLiteralType] -> ShowS

Query expressions

data QueryExpr

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).

Constructors

Select

Fields

• qeSetQuantifier :: SetQuantifier
• qeSelectList :: [(ScalarExpr, Maybe Name)]

  the expressions and the column aliases

• qeFrom :: [TableRef]
• qeWhere :: Maybe ScalarExpr
• qeGroupBy :: [GroupingExpr]
• qeHaving :: Maybe ScalarExpr
• qeOrderBy :: [SortSpec]
• qeOffset :: Maybe ScalarExpr
• qeFetchFirst :: Maybe ScalarExpr

QueryExprSetOp

Fields

• qe0 :: QueryExpr
• qeCombOp :: SetOperatorName
• qeSetQuantifier :: SetQuantifier
• qeCorresponding :: Corresponding
• qe1 :: QueryExpr

With

Fields

• qeWithRecursive :: Bool
• qeViews :: [(Alias, QueryExpr)]
• qeQueryExpression :: QueryExpr

Values [[ScalarExpr]]

Table [Name]

QEComment [Comment] QueryExpr

Instances

Eq QueryExpr

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data QueryExpr

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS QueryExpr

readList :: ReadS [QueryExpr]

readPrec :: ReadPrec QueryExpr

readListPrec :: ReadPrec [QueryExpr]

Show QueryExpr

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> QueryExpr -> ShowS

show :: QueryExpr -> String

showList :: [QueryExpr] -> ShowS

makeSelect :: QueryExpr

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

Query expression set operators.

Constructors

Union

Except

Intersect

Instances

Eq SetOperatorName

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: SetOperatorName -> SetOperatorName -> Bool

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

Data SetOperatorName

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS SetOperatorName

readList :: ReadS [SetOperatorName]

readPrec :: ReadPrec SetOperatorName

readListPrec :: ReadPrec [SetOperatorName]

Show SetOperatorName

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> SetOperatorName -> ShowS

show :: SetOperatorName -> String

showList :: [SetOperatorName] -> ShowS

data Corresponding

Corresponding, an option for the set operators.

Constructors

Corresponding

Respectively

Instances

Eq Corresponding

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: Corresponding -> Corresponding -> Bool

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

Data Corresponding

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS Corresponding

readList :: ReadS [Corresponding]

readPrec :: ReadPrec Corresponding

readListPrec :: ReadPrec [Corresponding]

Show Corresponding

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> Corresponding -> ShowS

show :: Corresponding -> String

showList :: [Corresponding] -> ShowS

data Alias

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data Alias

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS Alias

readList :: ReadS [Alias]

readPrec :: ReadPrec Alias

readListPrec :: ReadPrec [Alias]

Show Alias

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> Alias -> ShowS

show :: Alias -> String

showList :: [Alias] -> ShowS

data GroupingExpr

Represents an item in a group by clause.

Constructors

GroupingParens [GroupingExpr]

Cube [GroupingExpr]

Rollup [GroupingExpr]

GroupingSets [GroupingExpr]

SimpleGroup ScalarExpr

Instances

Eq GroupingExpr

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: GroupingExpr -> GroupingExpr -> Bool

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

Data GroupingExpr

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS GroupingExpr

readList :: ReadS [GroupingExpr]

readPrec :: ReadPrec GroupingExpr

readListPrec :: ReadPrec [GroupingExpr]

Show GroupingExpr

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> GroupingExpr -> ShowS

show :: GroupingExpr -> String

showList :: [GroupingExpr] -> ShowS

From

data TableRef

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data TableRef

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS TableRef

readList :: ReadS [TableRef]

readPrec :: ReadPrec TableRef

readListPrec :: ReadPrec [TableRef]

Show TableRef

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> TableRef -> ShowS

show :: TableRef -> String

showList :: [TableRef] -> ShowS

data JoinType

The type of a join.

Constructors

JInner

JLeft

JRight

JFull

JCross

Instances

Eq JoinType

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data JoinType

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS JoinType

readList :: ReadS [JoinType]

readPrec :: ReadPrec JoinType

readListPrec :: ReadPrec [JoinType]

Show JoinType

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> JoinType -> ShowS

show :: JoinType -> String

showList :: [JoinType] -> ShowS

data JoinCondition

The join condition.

Constructors

JoinOn ScalarExpr

on expr

JoinUsing [Name]

using (column list)

Instances

Eq JoinCondition

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: JoinCondition -> JoinCondition -> Bool

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

Data JoinCondition

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS JoinCondition

readList :: ReadS [JoinCondition]

readPrec :: ReadPrec JoinCondition

readListPrec :: ReadPrec [JoinCondition]

Show JoinCondition

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> JoinCondition -> ShowS

show :: JoinCondition -> String

showList :: [JoinCondition] -> ShowS

Statements

data Statement

Constructors

CreateSchema [Name]

DropSchema [Name] DropBehaviour

CreateTable [Name] [TableElement]

AlterTable [Name] AlterTableAction

DropTable [Name] DropBehaviour

CreateView Bool [Name] (Maybe [Name]) QueryExpr (Maybe CheckOption)

DropView [Name] DropBehaviour

CreateDomain [Name] TypeName (Maybe ScalarExpr) [(Maybe [Name], ScalarExpr)]

AlterDomain [Name] AlterDomainAction

DropDomain [Name] DropBehaviour

CreateAssertion [Name] ScalarExpr

DropAssertion [Name] DropBehaviour

CreateSequence [Name] [SequenceGeneratorOption]

AlterSequence [Name] [SequenceGeneratorOption]

DropSequence [Name] DropBehaviour

SelectStatement QueryExpr

Delete [Name] (Maybe Name) (Maybe ScalarExpr)

Truncate [Name] IdentityRestart

Insert [Name] (Maybe [Name]) InsertSource

Update [Name] (Maybe Name) [SetClause] (Maybe ScalarExpr)

GrantPrivilege [PrivilegeAction] PrivilegeObject [Name] GrantOption

GrantRole [Name] [Name] AdminOption

CreateRole Name

DropRole Name

RevokePrivilege GrantOptionFor [PrivilegeAction] PrivilegeObject [Name] DropBehaviour

RevokeRole AdminOptionFor [Name] [Name] DropBehaviour

StartTransaction

Savepoint Name

ReleaseSavepoint Name

Commit

Rollback (Maybe Name)

StatementComment [Comment]

Instances

Eq Statement

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data Statement

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS Statement

readList :: ReadS [Statement]

readPrec :: ReadPrec Statement

readListPrec :: ReadPrec [Statement]

Show Statement

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> Statement -> ShowS

show :: Statement -> String

showList :: [Statement] -> ShowS

data DropBehaviour

Constructors

Restrict

Cascade

DefaultDropBehaviour

Instances

Eq DropBehaviour

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: DropBehaviour -> DropBehaviour -> Bool

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

Data DropBehaviour

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS DropBehaviour

readList :: ReadS [DropBehaviour]

readPrec :: ReadPrec DropBehaviour

readListPrec :: ReadPrec [DropBehaviour]

Show DropBehaviour

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> DropBehaviour -> ShowS

show :: DropBehaviour -> String

showList :: [DropBehaviour] -> ShowS

data IdentityRestart

Constructors

ContinueIdentity

RestartIdentity

DefaultIdentityRestart

Instances

Eq IdentityRestart

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: IdentityRestart -> IdentityRestart -> Bool

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

Data IdentityRestart

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS IdentityRestart

readList :: ReadS [IdentityRestart]

readPrec :: ReadPrec IdentityRestart

readListPrec :: ReadPrec [IdentityRestart]

Show IdentityRestart

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> IdentityRestart -> ShowS

show :: IdentityRestart -> String

showList :: [IdentityRestart] -> ShowS

data InsertSource

Constructors

InsertQuery QueryExpr

DefaultInsertValues

Instances

Eq InsertSource

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: InsertSource -> InsertSource -> Bool

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

Data InsertSource

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS InsertSource

readList :: ReadS [InsertSource]

readPrec :: ReadPrec InsertSource

readListPrec :: ReadPrec [InsertSource]

Show InsertSource

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> InsertSource -> ShowS

show :: InsertSource -> String

showList :: [InsertSource] -> ShowS

data SetClause

Constructors

Set [Name] ScalarExpr

SetMultiple [[Name]] [ScalarExpr]

Instances

Eq SetClause

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data SetClause

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS SetClause

readList :: ReadS [SetClause]

readPrec :: ReadPrec SetClause

readListPrec :: ReadPrec [SetClause]

Show SetClause

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> SetClause -> ShowS

show :: SetClause -> String

showList :: [SetClause] -> ShowS

data TableElement

Constructors

TableColumnDef ColumnDef

TableConstraintDef (Maybe [Name]) TableConstraint

Instances

Eq TableElement

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: TableElement -> TableElement -> Bool

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

Data TableElement

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS TableElement

readList :: ReadS [TableElement]

readPrec :: ReadPrec TableElement

readListPrec :: ReadPrec [TableElement]

Show TableElement

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> TableElement -> ShowS

show :: TableElement -> String

showList :: [TableElement] -> ShowS

data ColumnDef

Constructors

ColumnDef Name TypeName (Maybe DefaultClause) [ColConstraintDef]

Instances

Eq ColumnDef

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: ColumnDef -> ColumnDef -> Bool

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

Data ColumnDef

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS ColumnDef

readList :: ReadS [ColumnDef]

readPrec :: ReadPrec ColumnDef

readListPrec :: ReadPrec [ColumnDef]

Show ColumnDef

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> ColumnDef -> ShowS

show :: ColumnDef -> String

showList :: [ColumnDef] -> ShowS

data DefaultClause

Constructors

DefaultClause ScalarExpr

IdentityColumnSpec IdentityWhen [SequenceGeneratorOption]

GenerationClause ScalarExpr

Instances

Eq DefaultClause

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: DefaultClause -> DefaultClause -> Bool

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

Data DefaultClause

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS DefaultClause

readList :: ReadS [DefaultClause]

readPrec :: ReadPrec DefaultClause

readListPrec :: ReadPrec [DefaultClause]

Show DefaultClause

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> DefaultClause -> ShowS

show :: DefaultClause -> String

showList :: [DefaultClause] -> ShowS

data IdentityWhen

Constructors

GeneratedAlways

GeneratedByDefault

Instances

Eq IdentityWhen

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: IdentityWhen -> IdentityWhen -> Bool

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

Data IdentityWhen

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS IdentityWhen

readList :: ReadS [IdentityWhen]

readPrec :: ReadPrec IdentityWhen

readListPrec :: ReadPrec [IdentityWhen]

Show IdentityWhen

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> IdentityWhen -> ShowS

show :: IdentityWhen -> String

showList :: [IdentityWhen] -> ShowS

data SequenceGeneratorOption

Constructors

SGODataType TypeName

SGOStartWith Integer

SGORestart (Maybe Integer)

SGOIncrementBy Integer

SGOMaxValue Integer

SGONoMaxValue

SGOMinValue Integer

SGONoMinValue

SGOCycle

SGONoCycle

Instances

Eq SequenceGeneratorOption

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: SequenceGeneratorOption -> SequenceGeneratorOption -> Bool

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

Data SequenceGeneratorOption

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS SequenceGeneratorOption

readList :: ReadS [SequenceGeneratorOption]

readPrec :: ReadPrec SequenceGeneratorOption

readListPrec :: ReadPrec [SequenceGeneratorOption]

Show SequenceGeneratorOption

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> SequenceGeneratorOption -> ShowS

show :: SequenceGeneratorOption -> String

showList :: [SequenceGeneratorOption] -> ShowS

data ColConstraintDef

Constructors

ColConstraintDef (Maybe [Name]) ColConstraint

Instances

Eq ColConstraintDef

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: ColConstraintDef -> ColConstraintDef -> Bool

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

Data ColConstraintDef

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS ColConstraintDef

readList :: ReadS [ColConstraintDef]

readPrec :: ReadPrec ColConstraintDef

readListPrec :: ReadPrec [ColConstraintDef]

Show ColConstraintDef

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> ColConstraintDef -> ShowS

show :: ColConstraintDef -> String

showList :: [ColConstraintDef] -> ShowS

data ColConstraint

Constructors

ColNotNullConstraint

ColUniqueConstraint

ColPrimaryKeyConstraint

ColReferencesConstraint [Name] (Maybe Name) ReferenceMatch ReferentialAction ReferentialAction

ColCheckConstraint ScalarExpr

Instances

Eq ColConstraint

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: ColConstraint -> ColConstraint -> Bool

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

Data ColConstraint

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS ColConstraint

readList :: ReadS [ColConstraint]

readPrec :: ReadPrec ColConstraint

readListPrec :: ReadPrec [ColConstraint]

Show ColConstraint

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> ColConstraint -> ShowS

show :: ColConstraint -> String

showList :: [ColConstraint] -> ShowS

data TableConstraint

Constructors

TableUniqueConstraint [Name]

TablePrimaryKeyConstraint [Name]

TableReferencesConstraint [Name] [Name] (Maybe [Name]) ReferenceMatch ReferentialAction ReferentialAction

TableCheckConstraint ScalarExpr

Instances

Eq TableConstraint

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: TableConstraint -> TableConstraint -> Bool

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

Data TableConstraint

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS TableConstraint

readList :: ReadS [TableConstraint]

readPrec :: ReadPrec TableConstraint

readListPrec :: ReadPrec [TableConstraint]

Show TableConstraint

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> TableConstraint -> ShowS

show :: TableConstraint -> String

showList :: [TableConstraint] -> ShowS

data ReferenceMatch

Constructors

DefaultReferenceMatch

MatchFull

MatchPartial

MatchSimple

Instances

Eq ReferenceMatch

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: ReferenceMatch -> ReferenceMatch -> Bool

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

Data ReferenceMatch

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS ReferenceMatch

readList :: ReadS [ReferenceMatch]

readPrec :: ReadPrec ReferenceMatch

readListPrec :: ReadPrec [ReferenceMatch]

Show ReferenceMatch

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> ReferenceMatch -> ShowS

show :: ReferenceMatch -> String

showList :: [ReferenceMatch] -> ShowS

data ReferentialAction

Constructors

DefaultReferentialAction

RefCascade

RefSetNull

RefSetDefault

RefRestrict

RefNoAction

Instances

Eq ReferentialAction

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: ReferentialAction -> ReferentialAction -> Bool

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

Data ReferentialAction

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS ReferentialAction

readList :: ReadS [ReferentialAction]

readPrec :: ReadPrec ReferentialAction

readListPrec :: ReadPrec [ReferentialAction]

Show ReferentialAction

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> ReferentialAction -> ShowS

show :: ReferentialAction -> String

showList :: [ReferentialAction] -> ShowS

data AlterTableAction

Constructors

AddColumnDef ColumnDef

AlterColumnSetDefault Name ScalarExpr

AlterColumnDropDefault Name

AlterColumnSetNotNull Name

AlterColumnDropNotNull Name

AlterColumnSetDataType Name TypeName

DropColumn Name DropBehaviour

AddTableConstraintDef (Maybe [Name]) TableConstraint

DropTableConstraintDef [Name] DropBehaviour

Instances

Eq AlterTableAction

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data AlterTableAction

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS AlterTableAction

readList :: ReadS [AlterTableAction]

readPrec :: ReadPrec AlterTableAction

readListPrec :: ReadPrec [AlterTableAction]

Show AlterTableAction

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> AlterTableAction -> ShowS

show :: AlterTableAction -> String

showList :: [AlterTableAction] -> ShowS

data CheckOption

Constructors

DefaultCheckOption

CascadedCheckOption

LocalCheckOption

Instances

Eq CheckOption

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: CheckOption -> CheckOption -> Bool

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

Data CheckOption

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS CheckOption

readList :: ReadS [CheckOption]

readPrec :: ReadPrec CheckOption

readListPrec :: ReadPrec [CheckOption]

Show CheckOption

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> CheckOption -> ShowS

show :: CheckOption -> String

showList :: [CheckOption] -> ShowS

data AlterDomainAction

Constructors

ADSetDefault ScalarExpr

ADDropDefault

ADAddConstraint (Maybe [Name]) ScalarExpr

ADDropConstraint [Name]

Instances

Eq AlterDomainAction

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: AlterDomainAction -> AlterDomainAction -> Bool

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

Data AlterDomainAction

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS AlterDomainAction

readList :: ReadS [AlterDomainAction]

readPrec :: ReadPrec AlterDomainAction

readListPrec :: ReadPrec [AlterDomainAction]

Show AlterDomainAction

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> AlterDomainAction -> ShowS

show :: AlterDomainAction -> String

showList :: [AlterDomainAction] -> ShowS

data AdminOption

Constructors

WithAdminOption

WithoutAdminOption

Instances

Eq AdminOption

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: AdminOption -> AdminOption -> Bool

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

Data AdminOption

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS AdminOption

readList :: ReadS [AdminOption]

readPrec :: ReadPrec AdminOption

readListPrec :: ReadPrec [AdminOption]

Show AdminOption

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> AdminOption -> ShowS

show :: AdminOption -> String

showList :: [AdminOption] -> ShowS

data GrantOption

Constructors

WithGrantOption

WithoutGrantOption

Instances

Eq GrantOption

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: GrantOption -> GrantOption -> Bool

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

Data GrantOption

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS GrantOption

readList :: ReadS [GrantOption]

readPrec :: ReadPrec GrantOption

readListPrec :: ReadPrec [GrantOption]

Show GrantOption

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> GrantOption -> ShowS

show :: GrantOption -> String

showList :: [GrantOption] -> ShowS

data PrivilegeObject

Constructors

PrivTable [Name]

PrivDomain [Name]

PrivType [Name]

PrivSequence [Name]

PrivFunction [Name]

Instances

Eq PrivilegeObject

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: PrivilegeObject -> PrivilegeObject -> Bool

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

Data PrivilegeObject

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS PrivilegeObject

readList :: ReadS [PrivilegeObject]

readPrec :: ReadPrec PrivilegeObject

readListPrec :: ReadPrec [PrivilegeObject]

Show PrivilegeObject

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> PrivilegeObject -> ShowS

show :: PrivilegeObject -> String

showList :: [PrivilegeObject] -> ShowS

data PrivilegeAction

Constructors

PrivAll

PrivSelect [Name]

PrivDelete

PrivInsert [Name]

PrivUpdate [Name]

PrivReferences [Name]

PrivUsage

PrivTrigger

PrivExecute

Instances

Eq PrivilegeAction

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: PrivilegeAction -> PrivilegeAction -> Bool

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

Data PrivilegeAction

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS PrivilegeAction

readList :: ReadS [PrivilegeAction]

readPrec :: ReadPrec PrivilegeAction

readListPrec :: ReadPrec [PrivilegeAction]

Show PrivilegeAction

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> PrivilegeAction -> ShowS

show :: PrivilegeAction -> String

showList :: [PrivilegeAction] -> ShowS

data AdminOptionFor

Constructors

AdminOptionFor

NoAdminOptionFor

Instances

Eq AdminOptionFor

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: AdminOptionFor -> AdminOptionFor -> Bool

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

Data AdminOptionFor

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS AdminOptionFor

readList :: ReadS [AdminOptionFor]

readPrec :: ReadPrec AdminOptionFor

readListPrec :: ReadPrec [AdminOptionFor]

Show AdminOptionFor

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> AdminOptionFor -> ShowS

show :: AdminOptionFor -> String

showList :: [AdminOptionFor] -> ShowS

data GrantOptionFor

Constructors

GrantOptionFor

NoGrantOptionFor

Instances

Eq GrantOptionFor

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: GrantOptionFor -> GrantOptionFor -> Bool

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

Data GrantOptionFor

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS GrantOptionFor

readList :: ReadS [GrantOptionFor]

readPrec :: ReadPrec GrantOptionFor

readListPrec :: ReadPrec [GrantOptionFor]

Show GrantOptionFor

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> GrantOptionFor -> ShowS

show :: GrantOptionFor -> String

showList :: [GrantOptionFor] -> ShowS

Comment

data Comment

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

Constructors

BlockComment String

Instances

Eq Comment

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data Comment

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

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS Comment

readList :: ReadS [Comment]

readPrec :: ReadPrec Comment

readListPrec :: ReadPrec [Comment]

Show Comment

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> Comment -> ShowS

show :: Comment -> String

showList :: [Comment] -> ShowS