Language.SQL.SimpleSQL.Syntax

The AST for SQL queries.

Value expressions

data ValueExpr

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

Constructors

NumLit String

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

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

StringLit String

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

IntervalLit

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

Fields

• ilSign :: Maybe Bool

  true if + used, false if - used

• ilLiteral :: String

  literal text

• ilFrom :: IntervalTypeField
• ilTo :: Maybe IntervalTypeField

Iden [Name]

identifier with parts separated by dots

Star

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

App [Name] [ValueExpr]

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

AggregateApp

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

Fields

• aggName :: [Name]

  aggregate function name

• aggDistinct :: SetQuantifier

  distinct

• aggArgs :: [ValueExpr]

  args

• aggOrderBy :: [SortSpec]

  order by

• aggFilter :: Maybe ValueExpr

  filter

AggregateAppGroup

aggregates with within group

Fields

• aggName :: [Name]

  aggregate function name

• aggArgs :: [ValueExpr]

  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 :: [ValueExpr]

  args

• wnPartition :: [ValueExpr]

  partition by

• wnOrderBy :: [SortSpec]

  order by

• wnFrame :: Maybe Frame

  frame clause

BinOp ValueExpr [Name] ValueExpr

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

PrefixOp [Name] ValueExpr

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

PostfixOp [Name] ValueExpr

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

SpecialOp [Name] [ValueExpr]

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

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

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

Case

case expression. both flavours supported

Fields

• caseTest :: Maybe ValueExpr

  test value

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

  when branches

• caseElse :: Maybe ValueExpr

  else value

Parens ValueExpr

Cast ValueExpr TypeName

cast(a as typename)

TypedLit TypeName String

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

SubQueryExpr SubQueryExprType QueryExpr

exists, all, any, some subqueries

In Bool ValueExpr InPredValue

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

Parameter

Represents a ? in a parameterized query

HostParameter String (Maybe String)

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

QuantifiedComparison ValueExpr [Name] CompPredQuantifier QueryExpr

Match ValueExpr Bool QueryExpr

Array ValueExpr [ValueExpr]

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

ArrayCtor QueryExpr

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

CSStringLit String String

Escape ValueExpr Char

UEscape ValueExpr Char

Collate ValueExpr [Name]

MultisetBinOp ValueExpr CombineOp SetQuantifier ValueExpr

MultisetCtor [ValueExpr]

MultisetQueryCtor QueryExpr

NextValueFor [Name]

VEComment [Comment] ValueExpr

Instances

Eq ValueExpr

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: ValueExpr -> ValueExpr -> Bool

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

Data ValueExpr

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: ValueExpr -> Constr

dataTypeOf :: ValueExpr -> DataType

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

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

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

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

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

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

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

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

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

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

Read ValueExpr

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS ValueExpr

readList :: ReadS [ValueExpr]

readPrec :: ReadPrec ValueExpr

readListPrec :: ReadPrec [ValueExpr]

Show ValueExpr

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> ValueExpr -> ShowS

show :: ValueExpr -> String

showList :: [ValueExpr] -> ShowS

data Name

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

Constructors

Name String

QName String

UQName String

DQName String String String

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

Instances

Eq Name

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 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 ValueExpr 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 (value expression list)', and 'expr in (subquery)' syntax.

Constructors

InList [ValueExpr]

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 value 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 ValueExpr

Current

Following ValueExpr

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

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 :: [(ValueExpr, Maybe Name)]

  the expressions and the column aliases

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

CombineQueryExpr

Fields

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

With

Fields

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

Values [[ValueExpr]]

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 CombineOp

Query expression set operators.

Constructors

Union

Except

Intersect

Instances

Eq CombineOp

Defined in Language.SQL.SimpleSQL.Syntax

Methods

(==) :: CombineOp -> CombineOp -> Bool

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

Data CombineOp

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: CombineOp -> Constr

dataTypeOf :: CombineOp -> DataType

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

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

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

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

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

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

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

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

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

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

Read CombineOp

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS CombineOp

readList :: ReadS [CombineOp]

readPrec :: ReadPrec CombineOp

readListPrec :: ReadPrec [CombineOp]

Show CombineOp

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> CombineOp -> ShowS

show :: CombineOp -> String

showList :: [CombineOp] -> 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 ValueExpr

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

from function(args)

TRLateral TableRef

from lateral t

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 ValueExpr

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

dialect

data Dialect

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

Constructors

SQL2011

MySQL

Instances

Eq Dialect

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

Data Dialect

Defined in Language.SQL.SimpleSQL.Syntax

Methods

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

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

toConstr :: Dialect -> Constr

dataTypeOf :: Dialect -> DataType

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

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

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

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

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

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

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

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

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

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

Read Dialect

Defined in Language.SQL.SimpleSQL.Syntax

Methods

readsPrec :: Int -> ReadS Dialect

readList :: ReadS [Dialect]

readPrec :: ReadPrec Dialect

readListPrec :: ReadPrec [Dialect]

Show Dialect

Defined in Language.SQL.SimpleSQL.Syntax

Methods

showsPrec :: Int -> Dialect -> ShowS

show :: Dialect -> String

showList :: [Dialect] -> ShowS

comment

data Comment

Comment. Useful when generating SQL code programmatically.

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