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

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

Constructors

NumLit String	a numeric literal optional decimal point, e+- integral exponent, e.g 10 10. .1 10.1 1e5 12.34e-6
StringLit String String String	string literal, with the start and end quote e.g. `test` -> StringLit "'" "'" "test"
IntervalLit	text of interval literal, units of interval precision, e.g. interval 3 days (3)
Fields 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 Source #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods (==) :: ScalarExpr -> ScalarExpr -> Bool # (/=) :: ScalarExpr -> ScalarExpr -> Bool #
Data ScalarExpr Source #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ScalarExpr -> c ScalarExpr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ScalarExpr # toConstr :: ScalarExpr -> Constr # dataTypeOf :: ScalarExpr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ScalarExpr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ScalarExpr) # gmapT :: (forall b. Data b => b -> b) -> ScalarExpr -> ScalarExpr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ScalarExpr -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ScalarExpr -> r # gmapQ :: (forall d. Data d => d -> u) -> ScalarExpr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ScalarExpr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ScalarExpr -> m ScalarExpr #
Read ScalarExpr Source #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods readsPrec :: Int -> ReadS ScalarExpr # readList :: ReadS [ScalarExpr] # readPrec :: ReadPrec ScalarExpr # readListPrec :: ReadPrec [ScalarExpr] #
Show ScalarExpr Source #
Instance details Defined in Language.SQL.SimpleSQL.Syntax Methods showsPrec :: Int -> ScalarExpr -> ShowS # show :: ScalarExpr -> String # showList :: [ScalarExpr] -> ShowS #

data Name Source #

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

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

Constructors

Name (Maybe (String, String)) String

Instances

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

data TypeName Source #

Represents a type name, used in casts.

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

data IntervalTypeField Source #

Constructors

Itf String (Maybe (Integer, Maybe Integer))

Instances

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

data Sign Source #

Constructors

Plus
Minus

Instances

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

data PrecMultiplier Source #

Constructors

PrecK
PrecM
PrecG
PrecT
PrecP

Instances

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

data PrecUnits Source #

Constructors

PrecCharacters
PrecOctets

Instances

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

data SetQuantifier Source #

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

Constructors

SQDefault
Distinct
All

Instances

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

data SortSpec Source #

Represents one field in an order by list.

Constructors

SortSpec ScalarExpr Direction NullsOrder

Instances

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

data Direction Source #

The direction for a column in order by.

Constructors

DirDefault
Asc
Desc

Instances

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

data NullsOrder Source #

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

Constructors

NullsOrderDefault
NullsFirst
NullsLast

Instances

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

data InPredValue Source #

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

Constructors

InList [ScalarExpr]
InQueryExpr QueryExpr

Instances

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

data SubQueryExprType Source #

A subquery in a scalar expression.

Constructors

SqExists	exists (query expr)
SqUnique	unique (query expr)
SqSq	a scalar subquery

Instances

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

data CompPredQuantifier Source #

Constructors

CPAny
CPSome
CPAll

Instances

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

data Frame Source #

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

Constructors

FrameFrom FrameRows FramePos
FrameBetween FrameRows FramePos FramePos

Instances

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

data FrameRows Source #

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

Constructors

FrameRows
FrameRange

Instances

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

data FramePos Source #

represents the start or end of a frame

Constructors

UnboundedPreceding
Preceding ScalarExpr
Current
Following ScalarExpr
UnboundedFollowing

Instances

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

data OdbcLiteralType Source #

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

Constructors

OLDate
OLTime
OLTimestamp

Instances

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

Query expressions

data QueryExpr Source #

Represents a query expression, which can be:

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

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

makeSelect :: QueryExpr Source #

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

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

data SetOperatorName Source #

Query expression set operators.

Constructors

Union
Except
Intersect

Instances

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

data Corresponding Source #

Corresponding, an option for the set operators.

Constructors

Corresponding
Respectively

Instances

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

data Alias Source #

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

Constructors

Alias Name (Maybe [Name])

Instances

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

data GroupingExpr Source #

Represents an item in a group by clause.

Constructors

GroupingParens [GroupingExpr]
Cube [GroupingExpr]
Rollup [GroupingExpr]
GroupingSets [GroupingExpr]
SimpleGroup ScalarExpr

Instances

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

From

data TableRef Source #

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

Constructors

TRSimple [Name]	from t / from s.t
TRJoin TableRef Bool JoinType TableRef (Maybe JoinCondition)	from a join b, the bool is true if natural was used
TRParens TableRef	from (a)
TRAlias TableRef Alias	from a as b(c,d)
TRQueryExpr QueryExpr	from (query expr)
TRFunction [Name] [ScalarExpr]	from function(args)
TRLateral TableRef	from lateral t
TROdbc TableRef	ODBC {oj t1 left outer join t2 on expr} syntax

Instances

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

data JoinType Source #

The type of a join.

Constructors

JInner
JLeft
JRight
JFull
JCross

Instances

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

data JoinCondition Source #

The join condition.

Constructors

JoinOn ScalarExpr	on expr
JoinUsing [Name]	using (column list)

Instances

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

Statements

data Statement Source #

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

data DropBehaviour Source #

Constructors

Restrict
Cascade
DefaultDropBehaviour

Instances

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

data IdentityRestart Source #

Constructors

ContinueIdentity
RestartIdentity
DefaultIdentityRestart

Instances

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

data InsertSource Source #

Constructors

InsertQuery QueryExpr
DefaultInsertValues

Instances

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

data SetClause Source #

Constructors

Set [Name] ScalarExpr
SetMultiple [[Name]] [ScalarExpr]

Instances

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

data TableElement Source #

Constructors

TableColumnDef ColumnDef
TableConstraintDef (Maybe [Name]) TableConstraint

Instances

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

data ColumnDef Source #

Constructors

ColumnDef Name TypeName (Maybe DefaultClause) [ColConstraintDef]

Instances

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

data DefaultClause Source #

Constructors

DefaultClause ScalarExpr
IdentityColumnSpec IdentityWhen [SequenceGeneratorOption]
GenerationClause ScalarExpr

Instances

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

data IdentityWhen Source #

Constructors

GeneratedAlways
GeneratedByDefault

Instances

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

data SequenceGeneratorOption Source #

Constructors

SGODataType TypeName
SGOStartWith Integer
SGORestart (Maybe Integer)
SGOIncrementBy Integer
SGOMaxValue Integer
SGONoMaxValue
SGOMinValue Integer
SGONoMinValue
SGOCycle
SGONoCycle

Instances

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

data ColConstraintDef Source #

Constructors

ColConstraintDef (Maybe [Name]) ColConstraint

Instances

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

data ColConstraint Source #

Constructors

ColNotNullConstraint
ColUniqueConstraint
ColPrimaryKeyConstraint
ColReferencesConstraint [Name] (Maybe Name) ReferenceMatch ReferentialAction ReferentialAction
ColCheckConstraint ScalarExpr

Instances

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

data TableConstraint Source #

Constructors

TableUniqueConstraint [Name]
TablePrimaryKeyConstraint [Name]
TableReferencesConstraint [Name] [Name] (Maybe [Name]) ReferenceMatch ReferentialAction ReferentialAction
TableCheckConstraint ScalarExpr

Instances

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

data ReferenceMatch Source #

Constructors

DefaultReferenceMatch
MatchFull
MatchPartial
MatchSimple

Instances

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

data ReferentialAction Source #

Constructors

DefaultReferentialAction
RefCascade
RefSetNull
RefSetDefault
RefRestrict
RefNoAction

Instances

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

data AlterTableAction Source #

Instances

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

data CheckOption Source #

Constructors

DefaultCheckOption
CascadedCheckOption
LocalCheckOption

Instances

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

data AlterDomainAction Source #

Constructors

ADSetDefault ScalarExpr
ADDropDefault
ADAddConstraint (Maybe [Name]) ScalarExpr
ADDropConstraint [Name]

Instances

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

data AdminOption Source #

Constructors

WithAdminOption
WithoutAdminOption

Instances

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

data GrantOption Source #

Constructors

WithGrantOption
WithoutGrantOption

Instances

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

data PrivilegeObject Source #

Constructors

PrivTable [Name]
PrivDomain [Name]
PrivType [Name]
PrivSequence [Name]
PrivFunction [Name]

Instances

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

data PrivilegeAction Source #

Constructors

PrivAll
PrivSelect [Name]
PrivDelete
PrivInsert [Name]
PrivUpdate [Name]
PrivReferences [Name]
PrivUsage
PrivTrigger
PrivExecute

Instances

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

data AdminOptionFor Source #

Constructors

AdminOptionFor
NoAdminOptionFor

Instances

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

data GrantOptionFor Source #

Constructors

GrantOptionFor
NoGrantOptionFor

Instances

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

Dialects

data Dialect Source #

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

Instances

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

ansi2011 :: Dialect Source #

ansi sql 2011 dialect

mysql :: Dialect Source #

mysql dialect

postgres :: Dialect Source #

postgresql dialect

oracle :: Dialect Source #

oracle dialect

sqlserver :: Dialect Source #

microsoft sql server dialect

Comment

data Comment Source #

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

Constructors

BlockComment String

Instances

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