Safe Haskell	Safe
Language	Haskell2010

Language.SQL.SimpleSQL.Syntax

Contents

Scalar expressions
Query expressions
- From
Statements
Dialects
Comment

Description

The AST for SQL.

Synopsis

data ScalarExpr
- = NumLit String
- | StringLit String String String
- | IntervalLit {
  - ilSign :: Maybe Sign
  - ilLiteral :: String
  - ilFrom :: IntervalTypeField
  - ilTo :: Maybe IntervalTypeField
  }
- | TypedLit TypeName String
- | Iden [Name]
- | Star
- | Parameter
- | PositionalArg Int
- | HostParameter String (Maybe String)
- | BinOp ScalarExpr [Name] ScalarExpr
- | PrefixOp [Name] ScalarExpr
- | PostfixOp [Name] ScalarExpr
- | SpecialOp [Name] [ScalarExpr]
- | App [Name] [ScalarExpr]
- | AggregateApp {
  - aggName :: [Name]
  - aggDistinct :: SetQuantifier
  - aggArgs :: [ScalarExpr]
  - aggOrderBy :: [SortSpec]
  - aggFilter :: Maybe ScalarExpr
  }
- | AggregateAppGroup {
  - aggName :: [Name]
  - aggArgs :: [ScalarExpr]
  - aggGroup :: [SortSpec]
  }
- | WindowApp {
  - wnName :: [Name]
  - wnArgs :: [ScalarExpr]
  - wnPartition :: [ScalarExpr]
  - wnOrderBy :: [SortSpec]
  - wnFrame :: Maybe Frame
  }
- | SpecialOpK [Name] (Maybe ScalarExpr) [(String, ScalarExpr)]
- | Cast ScalarExpr TypeName
- | Case {
  - caseTest :: Maybe ScalarExpr
  - caseWhens :: [([ScalarExpr], ScalarExpr)]
  - caseElse :: Maybe ScalarExpr
  }
- | Parens ScalarExpr
- | In Bool ScalarExpr InPredValue
- | SubQueryExpr SubQueryExprType QueryExpr
- | QuantifiedComparison ScalarExpr [Name] CompPredQuantifier QueryExpr
- | Match ScalarExpr Bool QueryExpr
- | Array ScalarExpr [ScalarExpr]
- | ArrayCtor QueryExpr
- | Collate ScalarExpr [Name]
- | MultisetBinOp ScalarExpr SetOperatorName SetQuantifier ScalarExpr
- | MultisetCtor [ScalarExpr]
- | MultisetQueryCtor QueryExpr
- | NextValueFor [Name]
- | VEComment [Comment] ScalarExpr
- | OdbcLiteral OdbcLiteralType String
- | OdbcFunc ScalarExpr
data Name = Name (Maybe (String, String)) String
data TypeName
- = 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
data IntervalTypeField = Itf String (Maybe (Integer, Maybe Integer))
data Sign
- = Plus
- | Minus
data PrecMultiplier
- = PrecK
- | PrecM
- | PrecG
- | PrecT
- | PrecP
data PrecUnits
- = PrecCharacters
- | PrecOctets
data SetQuantifier
- = SQDefault
- | Distinct
- | All
data SortSpec = SortSpec ScalarExpr Direction NullsOrder
data Direction
- = DirDefault
- | Asc
- | Desc
data NullsOrder
- = NullsOrderDefault
- | NullsFirst
- | NullsLast
data InPredValue
- = InList [ScalarExpr]
- | InQueryExpr QueryExpr
data SubQueryExprType
- = SqExists
- | SqUnique
- | SqSq
data CompPredQuantifier
- = CPAny
- | CPSome
- | CPAll
data Frame
- = FrameFrom FrameRows FramePos
- | FrameBetween FrameRows FramePos FramePos
data FrameRows
- = FrameRows
- | FrameRange
data FramePos
- = UnboundedPreceding
- | Preceding ScalarExpr
- | Current
- | Following ScalarExpr
- | UnboundedFollowing
data OdbcLiteralType
- = OLDate
- | OLTime
- | OLTimestamp
data QueryExpr
- = Select {
  - qeSetQuantifier :: SetQuantifier
  - qeSelectList :: [(ScalarExpr, Maybe Name)]
  - qeFrom :: [TableRef]
  - qeWhere :: Maybe ScalarExpr
  - qeGroupBy :: [GroupingExpr]
  - qeHaving :: Maybe ScalarExpr
  - qeOrderBy :: [SortSpec]
  - qeOffset :: Maybe ScalarExpr
  - qeFetchFirst :: Maybe ScalarExpr
  }
- | QueryExprSetOp {
  - qe0 :: QueryExpr
  - qeCombOp :: SetOperatorName
  - qeSetQuantifier :: SetQuantifier
  - qeCorresponding :: Corresponding
  - qe1 :: QueryExpr
  }
- | With {
  - qeWithRecursive :: Bool
  - qeViews :: [(Alias, QueryExpr)]
  - qeQueryExpression :: QueryExpr
  }
- | Values [[ScalarExpr]]
- | Table [Name]
- | QEComment [Comment] QueryExpr
makeSelect :: QueryExpr
data SetOperatorName
- = Union
- | Except
- | Intersect
data Corresponding
- = Corresponding
- | Respectively
data Alias = Alias Name (Maybe [Name])
data GroupingExpr
- = GroupingParens [GroupingExpr]
- | Cube [GroupingExpr]
- | Rollup [GroupingExpr]
- | GroupingSets [GroupingExpr]
- | SimpleGroup ScalarExpr
data TableRef
- = TRSimple [Name]
- | TRJoin TableRef Bool JoinType TableRef (Maybe JoinCondition)
- | TRParens TableRef
- | TRAlias TableRef Alias
- | TRQueryExpr QueryExpr
- | TRFunction [Name] [ScalarExpr]
- | TRLateral TableRef
- | TROdbc TableRef
data JoinType
- = JInner
- | JLeft
- | JRight
- | JFull
- | JCross
data JoinCondition
- = JoinOn ScalarExpr
- | JoinUsing [Name]
data Statement
- = 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]
data DropBehaviour
- = Restrict
- | Cascade
- | DefaultDropBehaviour
data IdentityRestart
- = ContinueIdentity
- | RestartIdentity
- | DefaultIdentityRestart
data InsertSource
- = InsertQuery QueryExpr
- | DefaultInsertValues
data SetClause
- = Set [Name] ScalarExpr
- | SetMultiple [[Name]] [ScalarExpr]
data TableElement
- = TableColumnDef ColumnDef
- | TableConstraintDef (Maybe [Name]) TableConstraint
data ColumnDef = ColumnDef Name TypeName (Maybe DefaultClause) [ColConstraintDef]
data DefaultClause
- = DefaultClause ScalarExpr
- | IdentityColumnSpec IdentityWhen [SequenceGeneratorOption]
- | GenerationClause ScalarExpr
data IdentityWhen
- = GeneratedAlways
- | GeneratedByDefault
data SequenceGeneratorOption
- = SGODataType TypeName
- | SGOStartWith Integer
- | SGORestart (Maybe Integer)
- | SGOIncrementBy Integer
- | SGOMaxValue Integer
- | SGONoMaxValue
- | SGOMinValue Integer
- | SGONoMinValue
- | SGOCycle
- | SGONoCycle
data ColConstraintDef = ColConstraintDef (Maybe [Name]) ColConstraint
data ColConstraint
- = ColNotNullConstraint
- | ColUniqueConstraint
- | ColPrimaryKeyConstraint
- | ColReferencesConstraint [Name] (Maybe Name) ReferenceMatch ReferentialAction ReferentialAction
- | ColCheckConstraint ScalarExpr
data TableConstraint
- = TableUniqueConstraint [Name]
- | TablePrimaryKeyConstraint [Name]
- | TableReferencesConstraint [Name] [Name] (Maybe [Name]) ReferenceMatch ReferentialAction ReferentialAction
- | TableCheckConstraint ScalarExpr
data ReferenceMatch
- = DefaultReferenceMatch
- | MatchFull
- | MatchPartial
- | MatchSimple
data ReferentialAction
- = DefaultReferentialAction
- | RefCascade
- | RefSetNull
- | RefSetDefault
- | RefRestrict
- | RefNoAction
data AlterTableAction
- = AddColumnDef ColumnDef
- | AlterColumnSetDefault Name ScalarExpr
- | AlterColumnDropDefault Name
- | AlterColumnSetNotNull Name
- | AlterColumnDropNotNull Name
- | AlterColumnSetDataType Name TypeName
- | DropColumn Name DropBehaviour
- | AddTableConstraintDef (Maybe [Name]) TableConstraint
- | DropTableConstraintDef [Name] DropBehaviour
data CheckOption
- = DefaultCheckOption
- | CascadedCheckOption
- | LocalCheckOption
data AlterDomainAction
- = ADSetDefault ScalarExpr
- | ADDropDefault
- | ADAddConstraint (Maybe [Name]) ScalarExpr
- | ADDropConstraint [Name]
data AdminOption
- = WithAdminOption
- | WithoutAdminOption
data GrantOption
- = WithGrantOption
- | WithoutGrantOption
data PrivilegeObject
- = PrivTable [Name]
- | PrivDomain [Name]
- | PrivType [Name]
- | PrivSequence [Name]
- | PrivFunction [Name]
data PrivilegeAction
- = PrivAll
- | PrivSelect [Name]
- | PrivDelete
- | PrivInsert [Name]
- | PrivUpdate [Name]
- | PrivReferences [Name]
- | PrivUsage
- | PrivTrigger
- | PrivExecute
data AdminOptionFor
- = AdminOptionFor
- | NoAdminOptionFor
data GrantOptionFor
- = GrantOptionFor
- | NoGrantOptionFor
data Dialect
ansi2011 :: Dialect
mysql :: Dialect
postgres :: Dialect
oracle :: Dialect
sqlserver :: Dialect
data Comment = BlockComment String

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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: ScalarExpr -> ScalarExpr -> Bool # (/=) :: ScalarExpr -> ScalarExpr -> Bool #
Data ScalarExpr #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ScalarExpr -> c ScalarExpr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ScalarExpr # toConstr :: ScalarExpr -> Constr # dataTypeOf :: ScalarExpr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ScalarExpr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ScalarExpr) # gmapT :: (forall b. Data b => b -> b) -> ScalarExpr -> ScalarExpr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ScalarExpr -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ScalarExpr -> r # gmapQ :: (forall d. Data d => d -> u) -> ScalarExpr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ScalarExpr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr #
Read ScalarExpr #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS ScalarExpr # readList :: ReadS [ScalarExpr] # readPrec :: ReadPrec ScalarExpr # readListPrec :: ReadPrec [ScalarExpr] #
Show ScalarExpr #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Data Name #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name # toConstr :: Name -> Constr # dataTypeOf :: Name -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Name) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) # gmapT :: (forall b. Data b => b -> b) -> Name -> Name # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r # gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name #
Read Name #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS Name # readList :: ReadS [Name] # readPrec :: ReadPrec Name # readListPrec :: ReadPrec [Name] #
Show Name #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: TypeName -> TypeName -> Bool # (/=) :: TypeName -> TypeName -> Bool #
Data TypeName #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeName -> c TypeName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeName # toConstr :: TypeName -> Constr # dataTypeOf :: TypeName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TypeName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeName) # gmapT :: (forall b. Data b => b -> b) -> TypeName -> TypeName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeName -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeName -> r # gmapQ :: (forall d. Data d => d -> u) -> TypeName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeName -> m TypeName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeName -> m TypeName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeName -> m TypeName #
Read TypeName #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS TypeName # readList :: ReadS [TypeName] # readPrec :: ReadPrec TypeName # readListPrec :: ReadPrec [TypeName] #
Show TypeName #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: IntervalTypeField -> IntervalTypeField -> Bool # (/=) :: IntervalTypeField -> IntervalTypeField -> Bool #
Data IntervalTypeField #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntervalTypeField -> c IntervalTypeField # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IntervalTypeField # toConstr :: IntervalTypeField -> Constr # dataTypeOf :: IntervalTypeField -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IntervalTypeField) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IntervalTypeField) # gmapT :: (forall b. Data b => b -> b) -> IntervalTypeField -> IntervalTypeField # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntervalTypeField -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntervalTypeField -> r # gmapQ :: (forall d. Data d => d -> u) -> IntervalTypeField -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IntervalTypeField -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IntervalTypeField -> m IntervalTypeField # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IntervalTypeField -> m IntervalTypeField # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IntervalTypeField -> m IntervalTypeField #
Read IntervalTypeField #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS IntervalTypeField # readList :: ReadS [IntervalTypeField] # readPrec :: ReadPrec IntervalTypeField # readListPrec :: ReadPrec [IntervalTypeField] #
Show IntervalTypeField #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: Sign -> Sign -> Bool # (/=) :: Sign -> Sign -> Bool #
Data Sign #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Sign -> c Sign # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Sign # toConstr :: Sign -> Constr # dataTypeOf :: Sign -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Sign) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign) # gmapT :: (forall b. Data b => b -> b) -> Sign -> Sign # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r # gmapQ :: (forall d. Data d => d -> u) -> Sign -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Sign -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sign -> m Sign # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sign -> m Sign # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sign -> m Sign #
Read Sign #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS Sign # readList :: ReadS [Sign] # readPrec :: ReadPrec Sign # readListPrec :: ReadPrec [Sign] #
Show Sign #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: PrecMultiplier -> PrecMultiplier -> Bool # (/=) :: PrecMultiplier -> PrecMultiplier -> Bool #
Data PrecMultiplier #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PrecMultiplier -> c PrecMultiplier # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PrecMultiplier # toConstr :: PrecMultiplier -> Constr # dataTypeOf :: PrecMultiplier -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PrecMultiplier) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrecMultiplier) # gmapT :: (forall b. Data b => b -> b) -> PrecMultiplier -> PrecMultiplier # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PrecMultiplier -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PrecMultiplier -> r # gmapQ :: (forall d. Data d => d -> u) -> PrecMultiplier -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PrecMultiplier -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PrecMultiplier -> m PrecMultiplier # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PrecMultiplier -> m PrecMultiplier # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PrecMultiplier -> m PrecMultiplier #
Read PrecMultiplier #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS PrecMultiplier # readList :: ReadS [PrecMultiplier] # readPrec :: ReadPrec PrecMultiplier # readListPrec :: ReadPrec [PrecMultiplier] #
Show PrecMultiplier #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: PrecUnits -> PrecUnits -> Bool # (/=) :: PrecUnits -> PrecUnits -> Bool #
Data PrecUnits #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PrecUnits -> c PrecUnits # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PrecUnits # toConstr :: PrecUnits -> Constr # dataTypeOf :: PrecUnits -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PrecUnits) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrecUnits) # gmapT :: (forall b. Data b => b -> b) -> PrecUnits -> PrecUnits # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PrecUnits -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PrecUnits -> r # gmapQ :: (forall d. Data d => d -> u) -> PrecUnits -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PrecUnits -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PrecUnits -> m PrecUnits #
Read PrecUnits #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS PrecUnits # readList :: ReadS [PrecUnits] # readPrec :: ReadPrec PrecUnits # readListPrec :: ReadPrec [PrecUnits] #
Show PrecUnits #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: SetQuantifier -> SetQuantifier -> Bool # (/=) :: SetQuantifier -> SetQuantifier -> Bool #
Data SetQuantifier #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SetQuantifier -> c SetQuantifier # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SetQuantifier # toConstr :: SetQuantifier -> Constr # dataTypeOf :: SetQuantifier -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SetQuantifier) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SetQuantifier) # gmapT :: (forall b. Data b => b -> b) -> SetQuantifier -> SetQuantifier # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SetQuantifier -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SetQuantifier -> r # gmapQ :: (forall d. Data d => d -> u) -> SetQuantifier -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SetQuantifier -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SetQuantifier -> m SetQuantifier #
Read SetQuantifier #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS SetQuantifier # readList :: ReadS [SetQuantifier] # readPrec :: ReadPrec SetQuantifier # readListPrec :: ReadPrec [SetQuantifier] #
Show SetQuantifier #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: SortSpec -> SortSpec -> Bool # (/=) :: SortSpec -> SortSpec -> Bool #
Data SortSpec #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SortSpec -> c SortSpec # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SortSpec # toConstr :: SortSpec -> Constr # dataTypeOf :: SortSpec -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SortSpec) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SortSpec) # gmapT :: (forall b. Data b => b -> b) -> SortSpec -> SortSpec # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SortSpec -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SortSpec -> r # gmapQ :: (forall d. Data d => d -> u) -> SortSpec -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SortSpec -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SortSpec -> m SortSpec # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SortSpec -> m SortSpec # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SortSpec -> m SortSpec #
Read SortSpec #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS SortSpec # readList :: ReadS [SortSpec] # readPrec :: ReadPrec SortSpec # readListPrec :: ReadPrec [SortSpec] #
Show SortSpec #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: Direction -> Direction -> Bool # (/=) :: Direction -> Direction -> Bool #
Data Direction #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Direction -> c Direction # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Direction # toConstr :: Direction -> Constr # dataTypeOf :: Direction -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Direction) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Direction) # gmapT :: (forall b. Data b => b -> b) -> Direction -> Direction # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Direction -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Direction -> r # gmapQ :: (forall d. Data d => d -> u) -> Direction -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Direction -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Direction -> m Direction # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Direction -> m Direction # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Direction -> m Direction #
Read Direction #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS Direction # readList :: ReadS [Direction] # readPrec :: ReadPrec Direction # readListPrec :: ReadPrec [Direction] #
Show Direction #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: NullsOrder -> NullsOrder -> Bool # (/=) :: NullsOrder -> NullsOrder -> Bool #
Data NullsOrder #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NullsOrder -> c NullsOrder # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NullsOrder # toConstr :: NullsOrder -> Constr # dataTypeOf :: NullsOrder -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NullsOrder) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NullsOrder) # gmapT :: (forall b. Data b => b -> b) -> NullsOrder -> NullsOrder # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NullsOrder -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NullsOrder -> r # gmapQ :: (forall d. Data d => d -> u) -> NullsOrder -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NullsOrder -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NullsOrder -> m NullsOrder #
Read NullsOrder #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS NullsOrder # readList :: ReadS [NullsOrder] # readPrec :: ReadPrec NullsOrder # readListPrec :: ReadPrec [NullsOrder] #
Show NullsOrder #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: InPredValue -> InPredValue -> Bool # (/=) :: InPredValue -> InPredValue -> Bool #
Data InPredValue #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InPredValue -> c InPredValue # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InPredValue # toConstr :: InPredValue -> Constr # dataTypeOf :: InPredValue -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c InPredValue) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InPredValue) # gmapT :: (forall b. Data b => b -> b) -> InPredValue -> InPredValue # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InPredValue -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InPredValue -> r # gmapQ :: (forall d. Data d => d -> u) -> InPredValue -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> InPredValue -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> InPredValue -> m InPredValue # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InPredValue -> m InPredValue # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InPredValue -> m InPredValue #
Read InPredValue #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS InPredValue # readList :: ReadS [InPredValue] # readPrec :: ReadPrec InPredValue # readListPrec :: ReadPrec [InPredValue] #
Show InPredValue #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: SubQueryExprType -> SubQueryExprType -> Bool # (/=) :: SubQueryExprType -> SubQueryExprType -> Bool #
Data SubQueryExprType #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SubQueryExprType -> c SubQueryExprType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SubQueryExprType # toConstr :: SubQueryExprType -> Constr # dataTypeOf :: SubQueryExprType -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SubQueryExprType) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubQueryExprType) # gmapT :: (forall b. Data b => b -> b) -> SubQueryExprType -> SubQueryExprType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SubQueryExprType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SubQueryExprType -> r # gmapQ :: (forall d. Data d => d -> u) -> SubQueryExprType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SubQueryExprType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SubQueryExprType -> m SubQueryExprType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SubQueryExprType -> m SubQueryExprType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SubQueryExprType -> m SubQueryExprType #
Read SubQueryExprType #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS SubQueryExprType # readList :: ReadS [SubQueryExprType] # readPrec :: ReadPrec SubQueryExprType # readListPrec :: ReadPrec [SubQueryExprType] #
Show SubQueryExprType #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: CompPredQuantifier -> CompPredQuantifier -> Bool # (/=) :: CompPredQuantifier -> CompPredQuantifier -> Bool #
Data CompPredQuantifier #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CompPredQuantifier -> c CompPredQuantifier # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CompPredQuantifier # toConstr :: CompPredQuantifier -> Constr # dataTypeOf :: CompPredQuantifier -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CompPredQuantifier) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompPredQuantifier) # gmapT :: (forall b. Data b => b -> b) -> CompPredQuantifier -> CompPredQuantifier # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CompPredQuantifier -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CompPredQuantifier -> r # gmapQ :: (forall d. Data d => d -> u) -> CompPredQuantifier -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CompPredQuantifier -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CompPredQuantifier -> m CompPredQuantifier # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CompPredQuantifier -> m CompPredQuantifier # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CompPredQuantifier -> m CompPredQuantifier #
Read CompPredQuantifier #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS CompPredQuantifier # readList :: ReadS [CompPredQuantifier] # readPrec :: ReadPrec CompPredQuantifier # readListPrec :: ReadPrec [CompPredQuantifier] #
Show CompPredQuantifier #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: Frame -> Frame -> Bool # (/=) :: Frame -> Frame -> Bool #
Data Frame #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Frame -> c Frame # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Frame # toConstr :: Frame -> Constr # dataTypeOf :: Frame -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Frame) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Frame) # gmapT :: (forall b. Data b => b -> b) -> Frame -> Frame # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Frame -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Frame -> r # gmapQ :: (forall d. Data d => d -> u) -> Frame -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Frame -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Frame -> m Frame # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Frame -> m Frame # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Frame -> m Frame #
Read Frame #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS Frame # readList :: ReadS [Frame] # readPrec :: ReadPrec Frame # readListPrec :: ReadPrec [Frame] #
Show Frame #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: FrameRows -> FrameRows -> Bool # (/=) :: FrameRows -> FrameRows -> Bool #
Data FrameRows #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FrameRows -> c FrameRows # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FrameRows # toConstr :: FrameRows -> Constr # dataTypeOf :: FrameRows -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FrameRows) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FrameRows) # gmapT :: (forall b. Data b => b -> b) -> FrameRows -> FrameRows # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FrameRows -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FrameRows -> r # gmapQ :: (forall d. Data d => d -> u) -> FrameRows -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FrameRows -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FrameRows -> m FrameRows # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FrameRows -> m FrameRows # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FrameRows -> m FrameRows #
Read FrameRows #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS FrameRows # readList :: ReadS [FrameRows] # readPrec :: ReadPrec FrameRows # readListPrec :: ReadPrec [FrameRows] #
Show FrameRows #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: FramePos -> FramePos -> Bool # (/=) :: FramePos -> FramePos -> Bool #
Data FramePos #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FramePos -> c FramePos # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FramePos # toConstr :: FramePos -> Constr # dataTypeOf :: FramePos -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FramePos) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FramePos) # gmapT :: (forall b. Data b => b -> b) -> FramePos -> FramePos # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FramePos -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FramePos -> r # gmapQ :: (forall d. Data d => d -> u) -> FramePos -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FramePos -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FramePos -> m FramePos # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FramePos -> m FramePos # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FramePos -> m FramePos #
Read FramePos #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS FramePos # readList :: ReadS [FramePos] # readPrec :: ReadPrec FramePos # readListPrec :: ReadPrec [FramePos] #
Show FramePos #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: OdbcLiteralType -> OdbcLiteralType -> Bool # (/=) :: OdbcLiteralType -> OdbcLiteralType -> Bool #
Data OdbcLiteralType #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OdbcLiteralType -> c OdbcLiteralType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OdbcLiteralType # toConstr :: OdbcLiteralType -> Constr # dataTypeOf :: OdbcLiteralType -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OdbcLiteralType) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OdbcLiteralType) # gmapT :: (forall b. Data b => b -> b) -> OdbcLiteralType -> OdbcLiteralType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OdbcLiteralType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OdbcLiteralType -> r # gmapQ :: (forall d. Data d => d -> u) -> OdbcLiteralType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OdbcLiteralType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OdbcLiteralType -> m OdbcLiteralType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OdbcLiteralType -> m OdbcLiteralType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OdbcLiteralType -> m OdbcLiteralType #
Read OdbcLiteralType #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS OdbcLiteralType # readList :: ReadS [OdbcLiteralType] # readPrec :: ReadPrec OdbcLiteralType # readListPrec :: ReadPrec [OdbcLiteralType] #
Show OdbcLiteralType #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: QueryExpr -> QueryExpr -> Bool # (/=) :: QueryExpr -> QueryExpr -> Bool #
Data QueryExpr #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QueryExpr -> c QueryExpr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c QueryExpr # toConstr :: QueryExpr -> Constr # dataTypeOf :: QueryExpr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c QueryExpr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QueryExpr) # gmapT :: (forall b. Data b => b -> b) -> QueryExpr -> QueryExpr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QueryExpr -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QueryExpr -> r # gmapQ :: (forall d. Data d => d -> u) -> QueryExpr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> QueryExpr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QueryExpr -> m QueryExpr #
Read QueryExpr #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS QueryExpr # readList :: ReadS [QueryExpr] # readPrec :: ReadPrec QueryExpr # readListPrec :: ReadPrec [QueryExpr] #
Show QueryExpr #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: SetOperatorName -> SetOperatorName -> Bool # (/=) :: SetOperatorName -> SetOperatorName -> Bool #
Data SetOperatorName #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SetOperatorName -> c SetOperatorName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SetOperatorName # toConstr :: SetOperatorName -> Constr # dataTypeOf :: SetOperatorName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SetOperatorName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SetOperatorName) # gmapT :: (forall b. Data b => b -> b) -> SetOperatorName -> SetOperatorName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SetOperatorName -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SetOperatorName -> r # gmapQ :: (forall d. Data d => d -> u) -> SetOperatorName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SetOperatorName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SetOperatorName -> m SetOperatorName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SetOperatorName -> m SetOperatorName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SetOperatorName -> m SetOperatorName #
Read SetOperatorName #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS SetOperatorName # readList :: ReadS [SetOperatorName] # readPrec :: ReadPrec SetOperatorName # readListPrec :: ReadPrec [SetOperatorName] #
Show SetOperatorName #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: Corresponding -> Corresponding -> Bool # (/=) :: Corresponding -> Corresponding -> Bool #
Data Corresponding #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Corresponding -> c Corresponding # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Corresponding # toConstr :: Corresponding -> Constr # dataTypeOf :: Corresponding -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Corresponding) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Corresponding) # gmapT :: (forall b. Data b => b -> b) -> Corresponding -> Corresponding # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Corresponding -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Corresponding -> r # gmapQ :: (forall d. Data d => d -> u) -> Corresponding -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Corresponding -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Corresponding -> m Corresponding # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Corresponding -> m Corresponding # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Corresponding -> m Corresponding #
Read Corresponding #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS Corresponding # readList :: ReadS [Corresponding] # readPrec :: ReadPrec Corresponding # readListPrec :: ReadPrec [Corresponding] #
Show Corresponding #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: Alias -> Alias -> Bool # (/=) :: Alias -> Alias -> Bool #
Data Alias #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Alias -> c Alias # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Alias # toConstr :: Alias -> Constr # dataTypeOf :: Alias -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Alias) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alias) # gmapT :: (forall b. Data b => b -> b) -> Alias -> Alias # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alias -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alias -> r # gmapQ :: (forall d. Data d => d -> u) -> Alias -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Alias -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alias -> m Alias # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alias -> m Alias # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alias -> m Alias #
Read Alias #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS Alias # readList :: ReadS [Alias] # readPrec :: ReadPrec Alias # readListPrec :: ReadPrec [Alias] #
Show Alias #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: GroupingExpr -> GroupingExpr -> Bool # (/=) :: GroupingExpr -> GroupingExpr -> Bool #
Data GroupingExpr #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GroupingExpr -> c GroupingExpr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c GroupingExpr # toConstr :: GroupingExpr -> Constr # dataTypeOf :: GroupingExpr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c GroupingExpr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GroupingExpr) # gmapT :: (forall b. Data b => b -> b) -> GroupingExpr -> GroupingExpr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GroupingExpr -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GroupingExpr -> r # gmapQ :: (forall d. Data d => d -> u) -> GroupingExpr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GroupingExpr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GroupingExpr -> m GroupingExpr #
Read GroupingExpr #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS GroupingExpr # readList :: ReadS [GroupingExpr] # readPrec :: ReadPrec GroupingExpr # readListPrec :: ReadPrec [GroupingExpr] #
Show GroupingExpr #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: TableRef -> TableRef -> Bool # (/=) :: TableRef -> TableRef -> Bool #
Data TableRef #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TableRef -> c TableRef # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TableRef # toConstr :: TableRef -> Constr # dataTypeOf :: TableRef -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TableRef) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableRef) # gmapT :: (forall b. Data b => b -> b) -> TableRef -> TableRef # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TableRef -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TableRef -> r # gmapQ :: (forall d. Data d => d -> u) -> TableRef -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TableRef -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TableRef -> m TableRef # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TableRef -> m TableRef # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TableRef -> m TableRef #
Read TableRef #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS TableRef # readList :: ReadS [TableRef] # readPrec :: ReadPrec TableRef # readListPrec :: ReadPrec [TableRef] #
Show TableRef #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: JoinType -> JoinType -> Bool # (/=) :: JoinType -> JoinType -> Bool #
Data JoinType #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JoinType -> c JoinType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c JoinType # toConstr :: JoinType -> Constr # dataTypeOf :: JoinType -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c JoinType) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinType) # gmapT :: (forall b. Data b => b -> b) -> JoinType -> JoinType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> JoinType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> JoinType -> r # gmapQ :: (forall d. Data d => d -> u) -> JoinType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> JoinType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> JoinType -> m JoinType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinType -> m JoinType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinType -> m JoinType #
Read JoinType #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS JoinType # readList :: ReadS [JoinType] # readPrec :: ReadPrec JoinType # readListPrec :: ReadPrec [JoinType] #
Show JoinType #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: JoinCondition -> JoinCondition -> Bool # (/=) :: JoinCondition -> JoinCondition -> Bool #
Data JoinCondition #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JoinCondition -> c JoinCondition # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c JoinCondition # toConstr :: JoinCondition -> Constr # dataTypeOf :: JoinCondition -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c JoinCondition) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JoinCondition) # gmapT :: (forall b. Data b => b -> b) -> JoinCondition -> JoinCondition # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> JoinCondition -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> JoinCondition -> r # gmapQ :: (forall d. Data d => d -> u) -> JoinCondition -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> JoinCondition -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JoinCondition -> m JoinCondition #
Read JoinCondition #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS JoinCondition # readList :: ReadS [JoinCondition] # readPrec :: ReadPrec JoinCondition # readListPrec :: ReadPrec [JoinCondition] #
Show JoinCondition #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: Statement -> Statement -> Bool # (/=) :: Statement -> Statement -> Bool #
Data Statement #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Statement -> c Statement # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Statement # toConstr :: Statement -> Constr # dataTypeOf :: Statement -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Statement) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement) # gmapT :: (forall b. Data b => b -> b) -> Statement -> Statement # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Statement -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Statement -> r # gmapQ :: (forall d. Data d => d -> u) -> Statement -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Statement -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Statement -> m Statement # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Statement -> m Statement # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Statement -> m Statement #
Read Statement #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS Statement # readList :: ReadS [Statement] # readPrec :: ReadPrec Statement # readListPrec :: ReadPrec [Statement] #
Show Statement #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: DropBehaviour -> DropBehaviour -> Bool # (/=) :: DropBehaviour -> DropBehaviour -> Bool #
Data DropBehaviour #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DropBehaviour -> c DropBehaviour # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DropBehaviour # toConstr :: DropBehaviour -> Constr # dataTypeOf :: DropBehaviour -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DropBehaviour) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DropBehaviour) # gmapT :: (forall b. Data b => b -> b) -> DropBehaviour -> DropBehaviour # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DropBehaviour -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DropBehaviour -> r # gmapQ :: (forall d. Data d => d -> u) -> DropBehaviour -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DropBehaviour -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DropBehaviour -> m DropBehaviour # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DropBehaviour -> m DropBehaviour # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DropBehaviour -> m DropBehaviour #
Read DropBehaviour #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS DropBehaviour # readList :: ReadS [DropBehaviour] # readPrec :: ReadPrec DropBehaviour # readListPrec :: ReadPrec [DropBehaviour] #
Show DropBehaviour #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: IdentityRestart -> IdentityRestart -> Bool # (/=) :: IdentityRestart -> IdentityRestart -> Bool #
Data IdentityRestart #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IdentityRestart -> c IdentityRestart # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IdentityRestart # toConstr :: IdentityRestart -> Constr # dataTypeOf :: IdentityRestart -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IdentityRestart) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IdentityRestart) # gmapT :: (forall b. Data b => b -> b) -> IdentityRestart -> IdentityRestart # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IdentityRestart -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IdentityRestart -> r # gmapQ :: (forall d. Data d => d -> u) -> IdentityRestart -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IdentityRestart -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IdentityRestart -> m IdentityRestart # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IdentityRestart -> m IdentityRestart # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IdentityRestart -> m IdentityRestart #
Read IdentityRestart #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS IdentityRestart # readList :: ReadS [IdentityRestart] # readPrec :: ReadPrec IdentityRestart # readListPrec :: ReadPrec [IdentityRestart] #
Show IdentityRestart #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: InsertSource -> InsertSource -> Bool # (/=) :: InsertSource -> InsertSource -> Bool #
Data InsertSource #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InsertSource -> c InsertSource # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InsertSource # toConstr :: InsertSource -> Constr # dataTypeOf :: InsertSource -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c InsertSource) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InsertSource) # gmapT :: (forall b. Data b => b -> b) -> InsertSource -> InsertSource # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InsertSource -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InsertSource -> r # gmapQ :: (forall d. Data d => d -> u) -> InsertSource -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> InsertSource -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> InsertSource -> m InsertSource # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InsertSource -> m InsertSource # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InsertSource -> m InsertSource #
Read InsertSource #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS InsertSource # readList :: ReadS [InsertSource] # readPrec :: ReadPrec InsertSource # readListPrec :: ReadPrec [InsertSource] #
Show InsertSource #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: SetClause -> SetClause -> Bool # (/=) :: SetClause -> SetClause -> Bool #
Data SetClause #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SetClause -> c SetClause # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SetClause # toConstr :: SetClause -> Constr # dataTypeOf :: SetClause -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SetClause) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SetClause) # gmapT :: (forall b. Data b => b -> b) -> SetClause -> SetClause # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SetClause -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SetClause -> r # gmapQ :: (forall d. Data d => d -> u) -> SetClause -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SetClause -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SetClause -> m SetClause # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SetClause -> m SetClause # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SetClause -> m SetClause #
Read SetClause #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS SetClause # readList :: ReadS [SetClause] # readPrec :: ReadPrec SetClause # readListPrec :: ReadPrec [SetClause] #
Show SetClause #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: TableElement -> TableElement -> Bool # (/=) :: TableElement -> TableElement -> Bool #
Data TableElement #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TableElement -> c TableElement # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TableElement # toConstr :: TableElement -> Constr # dataTypeOf :: TableElement -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TableElement) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableElement) # gmapT :: (forall b. Data b => b -> b) -> TableElement -> TableElement # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TableElement -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TableElement -> r # gmapQ :: (forall d. Data d => d -> u) -> TableElement -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TableElement -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TableElement -> m TableElement # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TableElement -> m TableElement # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TableElement -> m TableElement #
Read TableElement #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS TableElement # readList :: ReadS [TableElement] # readPrec :: ReadPrec TableElement # readListPrec :: ReadPrec [TableElement] #
Show TableElement #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: ColumnDef -> ColumnDef -> Bool # (/=) :: ColumnDef -> ColumnDef -> Bool #
Data ColumnDef #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ColumnDef -> c ColumnDef # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ColumnDef # toConstr :: ColumnDef -> Constr # dataTypeOf :: ColumnDef -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ColumnDef) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColumnDef) # gmapT :: (forall b. Data b => b -> b) -> ColumnDef -> ColumnDef # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ColumnDef -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ColumnDef -> r # gmapQ :: (forall d. Data d => d -> u) -> ColumnDef -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ColumnDef -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ColumnDef -> m ColumnDef # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ColumnDef -> m ColumnDef # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ColumnDef -> m ColumnDef #
Read ColumnDef #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS ColumnDef # readList :: ReadS [ColumnDef] # readPrec :: ReadPrec ColumnDef # readListPrec :: ReadPrec [ColumnDef] #
Show ColumnDef #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: DefaultClause -> DefaultClause -> Bool # (/=) :: DefaultClause -> DefaultClause -> Bool #
Data DefaultClause #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DefaultClause -> c DefaultClause # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DefaultClause # toConstr :: DefaultClause -> Constr # dataTypeOf :: DefaultClause -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DefaultClause) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DefaultClause) # gmapT :: (forall b. Data b => b -> b) -> DefaultClause -> DefaultClause # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DefaultClause -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DefaultClause -> r # gmapQ :: (forall d. Data d => d -> u) -> DefaultClause -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DefaultClause -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DefaultClause -> m DefaultClause # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultClause -> m DefaultClause # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DefaultClause -> m DefaultClause #
Read DefaultClause #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS DefaultClause # readList :: ReadS [DefaultClause] # readPrec :: ReadPrec DefaultClause # readListPrec :: ReadPrec [DefaultClause] #
Show DefaultClause #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: IdentityWhen -> IdentityWhen -> Bool # (/=) :: IdentityWhen -> IdentityWhen -> Bool #
Data IdentityWhen #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IdentityWhen -> c IdentityWhen # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IdentityWhen # toConstr :: IdentityWhen -> Constr # dataTypeOf :: IdentityWhen -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IdentityWhen) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IdentityWhen) # gmapT :: (forall b. Data b => b -> b) -> IdentityWhen -> IdentityWhen # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IdentityWhen -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IdentityWhen -> r # gmapQ :: (forall d. Data d => d -> u) -> IdentityWhen -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IdentityWhen -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IdentityWhen -> m IdentityWhen # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IdentityWhen -> m IdentityWhen # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IdentityWhen -> m IdentityWhen #
Read IdentityWhen #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS IdentityWhen # readList :: ReadS [IdentityWhen] # readPrec :: ReadPrec IdentityWhen # readListPrec :: ReadPrec [IdentityWhen] #
Show IdentityWhen #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: SequenceGeneratorOption -> SequenceGeneratorOption -> Bool # (/=) :: SequenceGeneratorOption -> SequenceGeneratorOption -> Bool #
Data SequenceGeneratorOption #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SequenceGeneratorOption -> c SequenceGeneratorOption # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SequenceGeneratorOption # toConstr :: SequenceGeneratorOption -> Constr # dataTypeOf :: SequenceGeneratorOption -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SequenceGeneratorOption) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SequenceGeneratorOption) # gmapT :: (forall b. Data b => b -> b) -> SequenceGeneratorOption -> SequenceGeneratorOption # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SequenceGeneratorOption -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SequenceGeneratorOption -> r # gmapQ :: (forall d. Data d => d -> u) -> SequenceGeneratorOption -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SequenceGeneratorOption -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SequenceGeneratorOption -> m SequenceGeneratorOption # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SequenceGeneratorOption -> m SequenceGeneratorOption # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SequenceGeneratorOption -> m SequenceGeneratorOption #
Read SequenceGeneratorOption #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS SequenceGeneratorOption # readList :: ReadS [SequenceGeneratorOption] # readPrec :: ReadPrec SequenceGeneratorOption # readListPrec :: ReadPrec [SequenceGeneratorOption] #
Show SequenceGeneratorOption #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: ColConstraintDef -> ColConstraintDef -> Bool # (/=) :: ColConstraintDef -> ColConstraintDef -> Bool #
Data ColConstraintDef #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ColConstraintDef -> c ColConstraintDef # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ColConstraintDef # toConstr :: ColConstraintDef -> Constr # dataTypeOf :: ColConstraintDef -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ColConstraintDef) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColConstraintDef) # gmapT :: (forall b. Data b => b -> b) -> ColConstraintDef -> ColConstraintDef # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ColConstraintDef -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ColConstraintDef -> r # gmapQ :: (forall d. Data d => d -> u) -> ColConstraintDef -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ColConstraintDef -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ColConstraintDef -> m ColConstraintDef # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ColConstraintDef -> m ColConstraintDef # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ColConstraintDef -> m ColConstraintDef #
Read ColConstraintDef #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS ColConstraintDef # readList :: ReadS [ColConstraintDef] # readPrec :: ReadPrec ColConstraintDef # readListPrec :: ReadPrec [ColConstraintDef] #
Show ColConstraintDef #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: ColConstraint -> ColConstraint -> Bool # (/=) :: ColConstraint -> ColConstraint -> Bool #
Data ColConstraint #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ColConstraint -> c ColConstraint # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ColConstraint # toConstr :: ColConstraint -> Constr # dataTypeOf :: ColConstraint -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ColConstraint) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ColConstraint) # gmapT :: (forall b. Data b => b -> b) -> ColConstraint -> ColConstraint # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ColConstraint -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ColConstraint -> r # gmapQ :: (forall d. Data d => d -> u) -> ColConstraint -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ColConstraint -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ColConstraint -> m ColConstraint # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ColConstraint -> m ColConstraint # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ColConstraint -> m ColConstraint #
Read ColConstraint #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS ColConstraint # readList :: ReadS [ColConstraint] # readPrec :: ReadPrec ColConstraint # readListPrec :: ReadPrec [ColConstraint] #
Show ColConstraint #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: TableConstraint -> TableConstraint -> Bool # (/=) :: TableConstraint -> TableConstraint -> Bool #
Data TableConstraint #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TableConstraint -> c TableConstraint # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TableConstraint # toConstr :: TableConstraint -> Constr # dataTypeOf :: TableConstraint -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TableConstraint) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TableConstraint) # gmapT :: (forall b. Data b => b -> b) -> TableConstraint -> TableConstraint # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TableConstraint -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TableConstraint -> r # gmapQ :: (forall d. Data d => d -> u) -> TableConstraint -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TableConstraint -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TableConstraint -> m TableConstraint # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TableConstraint -> m TableConstraint # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TableConstraint -> m TableConstraint #
Read TableConstraint #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS TableConstraint # readList :: ReadS [TableConstraint] # readPrec :: ReadPrec TableConstraint # readListPrec :: ReadPrec [TableConstraint] #
Show TableConstraint #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: ReferenceMatch -> ReferenceMatch -> Bool # (/=) :: ReferenceMatch -> ReferenceMatch -> Bool #
Data ReferenceMatch #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ReferenceMatch -> c ReferenceMatch # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ReferenceMatch # toConstr :: ReferenceMatch -> Constr # dataTypeOf :: ReferenceMatch -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ReferenceMatch) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ReferenceMatch) # gmapT :: (forall b. Data b => b -> b) -> ReferenceMatch -> ReferenceMatch # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ReferenceMatch -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ReferenceMatch -> r # gmapQ :: (forall d. Data d => d -> u) -> ReferenceMatch -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ReferenceMatch -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ReferenceMatch -> m ReferenceMatch # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ReferenceMatch -> m ReferenceMatch # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ReferenceMatch -> m ReferenceMatch #
Read ReferenceMatch #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS ReferenceMatch # readList :: ReadS [ReferenceMatch] # readPrec :: ReadPrec ReferenceMatch # readListPrec :: ReadPrec [ReferenceMatch] #
Show ReferenceMatch #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: ReferentialAction -> ReferentialAction -> Bool # (/=) :: ReferentialAction -> ReferentialAction -> Bool #
Data ReferentialAction #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ReferentialAction -> c ReferentialAction # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ReferentialAction # toConstr :: ReferentialAction -> Constr # dataTypeOf :: ReferentialAction -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ReferentialAction) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ReferentialAction) # gmapT :: (forall b. Data b => b -> b) -> ReferentialAction -> ReferentialAction # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ReferentialAction -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ReferentialAction -> r # gmapQ :: (forall d. Data d => d -> u) -> ReferentialAction -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ReferentialAction -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ReferentialAction -> m ReferentialAction # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ReferentialAction -> m ReferentialAction # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ReferentialAction -> m ReferentialAction #
Read ReferentialAction #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS ReferentialAction # readList :: ReadS [ReferentialAction] # readPrec :: ReadPrec ReferentialAction # readListPrec :: ReadPrec [ReferentialAction] #
Show ReferentialAction #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods showsPrec :: Int -> ReferentialAction -> ShowS # show :: ReferentialAction -> String # showList :: [ReferentialAction] -> ShowS #

data AlterTableAction #

Instances

Eq AlterTableAction #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: AlterTableAction -> AlterTableAction -> Bool # (/=) :: AlterTableAction -> AlterTableAction -> Bool #
Data AlterTableAction #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AlterTableAction -> c AlterTableAction # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AlterTableAction # toConstr :: AlterTableAction -> Constr # dataTypeOf :: AlterTableAction -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AlterTableAction) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlterTableAction) # gmapT :: (forall b. Data b => b -> b) -> AlterTableAction -> AlterTableAction # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AlterTableAction -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AlterTableAction -> r # gmapQ :: (forall d. Data d => d -> u) -> AlterTableAction -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AlterTableAction -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AlterTableAction -> m AlterTableAction # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterTableAction -> m AlterTableAction # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterTableAction -> m AlterTableAction #
Read AlterTableAction #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS AlterTableAction # readList :: ReadS [AlterTableAction] # readPrec :: ReadPrec AlterTableAction # readListPrec :: ReadPrec [AlterTableAction] #
Show AlterTableAction #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: CheckOption -> CheckOption -> Bool # (/=) :: CheckOption -> CheckOption -> Bool #
Data CheckOption #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CheckOption -> c CheckOption # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CheckOption # toConstr :: CheckOption -> Constr # dataTypeOf :: CheckOption -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CheckOption) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CheckOption) # gmapT :: (forall b. Data b => b -> b) -> CheckOption -> CheckOption # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CheckOption -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CheckOption -> r # gmapQ :: (forall d. Data d => d -> u) -> CheckOption -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CheckOption -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CheckOption -> m CheckOption # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CheckOption -> m CheckOption # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CheckOption -> m CheckOption #
Read CheckOption #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS CheckOption # readList :: ReadS [CheckOption] # readPrec :: ReadPrec CheckOption # readListPrec :: ReadPrec [CheckOption] #
Show CheckOption #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: AlterDomainAction -> AlterDomainAction -> Bool # (/=) :: AlterDomainAction -> AlterDomainAction -> Bool #
Data AlterDomainAction #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AlterDomainAction -> c AlterDomainAction # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AlterDomainAction # toConstr :: AlterDomainAction -> Constr # dataTypeOf :: AlterDomainAction -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AlterDomainAction) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlterDomainAction) # gmapT :: (forall b. Data b => b -> b) -> AlterDomainAction -> AlterDomainAction # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AlterDomainAction -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AlterDomainAction -> r # gmapQ :: (forall d. Data d => d -> u) -> AlterDomainAction -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AlterDomainAction -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AlterDomainAction -> m AlterDomainAction # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterDomainAction -> m AlterDomainAction # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AlterDomainAction -> m AlterDomainAction #
Read AlterDomainAction #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS AlterDomainAction # readList :: ReadS [AlterDomainAction] # readPrec :: ReadPrec AlterDomainAction # readListPrec :: ReadPrec [AlterDomainAction] #
Show AlterDomainAction #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: AdminOption -> AdminOption -> Bool # (/=) :: AdminOption -> AdminOption -> Bool #
Data AdminOption #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AdminOption -> c AdminOption # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AdminOption # toConstr :: AdminOption -> Constr # dataTypeOf :: AdminOption -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AdminOption) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AdminOption) # gmapT :: (forall b. Data b => b -> b) -> AdminOption -> AdminOption # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AdminOption -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AdminOption -> r # gmapQ :: (forall d. Data d => d -> u) -> AdminOption -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AdminOption -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AdminOption -> m AdminOption # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AdminOption -> m AdminOption # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AdminOption -> m AdminOption #
Read AdminOption #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS AdminOption # readList :: ReadS [AdminOption] # readPrec :: ReadPrec AdminOption # readListPrec :: ReadPrec [AdminOption] #
Show AdminOption #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: GrantOption -> GrantOption -> Bool # (/=) :: GrantOption -> GrantOption -> Bool #
Data GrantOption #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GrantOption -> c GrantOption # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c GrantOption # toConstr :: GrantOption -> Constr # dataTypeOf :: GrantOption -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c GrantOption) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GrantOption) # gmapT :: (forall b. Data b => b -> b) -> GrantOption -> GrantOption # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GrantOption -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GrantOption -> r # gmapQ :: (forall d. Data d => d -> u) -> GrantOption -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GrantOption -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GrantOption -> m GrantOption # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GrantOption -> m GrantOption # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GrantOption -> m GrantOption #
Read GrantOption #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS GrantOption # readList :: ReadS [GrantOption] # readPrec :: ReadPrec GrantOption # readListPrec :: ReadPrec [GrantOption] #
Show GrantOption #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: PrivilegeObject -> PrivilegeObject -> Bool # (/=) :: PrivilegeObject -> PrivilegeObject -> Bool #
Data PrivilegeObject #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PrivilegeObject -> c PrivilegeObject # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PrivilegeObject # toConstr :: PrivilegeObject -> Constr # dataTypeOf :: PrivilegeObject -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PrivilegeObject) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrivilegeObject) # gmapT :: (forall b. Data b => b -> b) -> PrivilegeObject -> PrivilegeObject # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PrivilegeObject -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PrivilegeObject -> r # gmapQ :: (forall d. Data d => d -> u) -> PrivilegeObject -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PrivilegeObject -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PrivilegeObject -> m PrivilegeObject # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PrivilegeObject -> m PrivilegeObject # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PrivilegeObject -> m PrivilegeObject #
Read PrivilegeObject #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS PrivilegeObject # readList :: ReadS [PrivilegeObject] # readPrec :: ReadPrec PrivilegeObject # readListPrec :: ReadPrec [PrivilegeObject] #
Show PrivilegeObject #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: PrivilegeAction -> PrivilegeAction -> Bool # (/=) :: PrivilegeAction -> PrivilegeAction -> Bool #
Data PrivilegeAction #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PrivilegeAction -> c PrivilegeAction # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PrivilegeAction # toConstr :: PrivilegeAction -> Constr # dataTypeOf :: PrivilegeAction -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PrivilegeAction) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrivilegeAction) # gmapT :: (forall b. Data b => b -> b) -> PrivilegeAction -> PrivilegeAction # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PrivilegeAction -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PrivilegeAction -> r # gmapQ :: (forall d. Data d => d -> u) -> PrivilegeAction -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PrivilegeAction -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PrivilegeAction -> m PrivilegeAction # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PrivilegeAction -> m PrivilegeAction # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PrivilegeAction -> m PrivilegeAction #
Read PrivilegeAction #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS PrivilegeAction # readList :: ReadS [PrivilegeAction] # readPrec :: ReadPrec PrivilegeAction # readListPrec :: ReadPrec [PrivilegeAction] #
Show PrivilegeAction #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: AdminOptionFor -> AdminOptionFor -> Bool # (/=) :: AdminOptionFor -> AdminOptionFor -> Bool #
Data AdminOptionFor #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AdminOptionFor -> c AdminOptionFor # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AdminOptionFor # toConstr :: AdminOptionFor -> Constr # dataTypeOf :: AdminOptionFor -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AdminOptionFor) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AdminOptionFor) # gmapT :: (forall b. Data b => b -> b) -> AdminOptionFor -> AdminOptionFor # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AdminOptionFor -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AdminOptionFor -> r # gmapQ :: (forall d. Data d => d -> u) -> AdminOptionFor -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AdminOptionFor -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AdminOptionFor -> m AdminOptionFor # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AdminOptionFor -> m AdminOptionFor # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AdminOptionFor -> m AdminOptionFor #
Read AdminOptionFor #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS AdminOptionFor # readList :: ReadS [AdminOptionFor] # readPrec :: ReadPrec AdminOptionFor # readListPrec :: ReadPrec [AdminOptionFor] #
Show AdminOptionFor #
Instance details 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 #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: GrantOptionFor -> GrantOptionFor -> Bool # (/=) :: GrantOptionFor -> GrantOptionFor -> Bool #
Data GrantOptionFor #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GrantOptionFor -> c GrantOptionFor # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c GrantOptionFor # toConstr :: GrantOptionFor -> Constr # dataTypeOf :: GrantOptionFor -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c GrantOptionFor) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GrantOptionFor) # gmapT :: (forall b. Data b => b -> b) -> GrantOptionFor -> GrantOptionFor # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GrantOptionFor -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GrantOptionFor -> r # gmapQ :: (forall d. Data d => d -> u) -> GrantOptionFor -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GrantOptionFor -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GrantOptionFor -> m GrantOptionFor # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GrantOptionFor -> m GrantOptionFor # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GrantOptionFor -> m GrantOptionFor #
Read GrantOptionFor #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS GrantOptionFor # readList :: ReadS [GrantOptionFor] # readPrec :: ReadPrec GrantOptionFor # readListPrec :: ReadPrec [GrantOptionFor] #
Show GrantOptionFor #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods showsPrec :: Int -> GrantOptionFor -> ShowS # show :: GrantOptionFor -> String # showList :: [GrantOptionFor] -> ShowS #

Dialects

data Dialect #

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

Instances

Eq Dialect #
Instance details Defined in Language.SQL.SimpleSQL.Dialect Methods (==) :: Dialect -> Dialect -> Bool # (/=) :: Dialect -> Dialect -> Bool #
Data Dialect #
Instance details Defined in Language.SQL.SimpleSQL.Dialect 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 #
Instance details Defined in Language.SQL.SimpleSQL.Dialect Methods readsPrec :: Int -> ReadS Dialect # readList :: ReadS [Dialect] # readPrec :: ReadPrec Dialect # readListPrec :: ReadPrec [Dialect] #
Show Dialect #
Instance details Defined in Language.SQL.SimpleSQL.Dialect Methods showsPrec :: Int -> Dialect -> ShowS # show :: Dialect -> String # showList :: [Dialect] -> ShowS #

ansi2011 :: Dialect #

ansi sql 2011 dialect

mysql :: Dialect #

mysql dialect

postgres :: Dialect #

postgresql dialect

oracle :: Dialect #

oracle dialect

sqlserver :: Dialect #

microsoft sql server dialect

Comment

data Comment #

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

Constructors

BlockComment String

Instances

Eq Comment #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: Comment -> Comment -> Bool # (/=) :: Comment -> Comment -> Bool #
Data Comment #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Comment -> c Comment # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Comment # toConstr :: Comment -> Constr # dataTypeOf :: Comment -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Comment) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Comment) # gmapT :: (forall b. Data b => b -> b) -> Comment -> Comment # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Comment -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Comment -> r # gmapQ :: (forall d. Data d => d -> u) -> Comment -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Comment -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Comment -> m Comment # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Comment -> m Comment # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Comment -> m Comment #
Read Comment #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS Comment # readList :: ReadS [Comment] # readPrec :: ReadPrec Comment # readListPrec :: ReadPrec [Comment] #
Show Comment #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods showsPrec :: Int -> Comment -> ShowS # show :: Comment -> String # showList :: [Comment] -> ShowS #

AddColumnDef ColumnDef
AlterColumnSetDefault Name ScalarExpr
AlterColumnDropDefault Name
AlterColumnSetNotNull Name
AlterColumnDropNotNull Name
AlterColumnSetDataType Name TypeName
DropColumn Name DropBehaviour
AddTableConstraintDef (Maybe [Name]) TableConstraint
DropTableConstraintDef [Name] DropBehaviour