Copyright	2017 Kei Hibino
License	BSD3
Maintainer	[email protected]
Stability	experimental
Portability	unknown
Safe Haskell	Safe-Inferred
Language	Haskell2010

Database.Relational.SqlSyntax

Contents

The SubQuery
Set operations
Qualifiers for nested query
Ordering types
Aggregating types
Product tree type
Case
Column, Tuple, Record and Projection
Predicate to restrict Query result
Sub-query
Qualified Sub-query
Sub-query columns
Tuple and Record
Query restriction
Aggregation
Ordering
Update and Insert assignments

Description

This module is integrated module of sql-syntax.

Synopsis

data SubQuery
- = Table Untyped
- | Flat Config Tuple Duplication JoinProduct [Predicate Flat] [OrderingTerm]
- | Aggregated Config Tuple Duplication JoinProduct [Predicate Flat] [AggregateElem] [Predicate Aggregated] [OrderingTerm]
- | Bin BinOp SubQuery SubQuery
data Duplication
- = All
- | Distinct
data SetOp
- = Union
- | Except
- | Intersect
newtype BinOp = BinOp (SetOp, Duplication)
newtype Qualifier = Qualifier Int
data Qualified a = Qualified Qualifier a
qualifier :: Qualified a -> Qualifier
unQualify :: Qualified a -> a
qualify :: Qualifier -> a -> Qualified a
data Order
- = Asc
- | Desc
data Nulls
- = NullsFirst
- | NullsLast
type OrderColumn = Column
type OrderingTerm = ((Order, Maybe Nulls), OrderColumn)
type AggregateColumnRef = Column
newtype AggregateBitKey = AggregateBitKey [AggregateColumnRef]
newtype AggregateSet = AggregateSet [AggregateElem]
data AggregateElem
- = ColumnRef AggregateColumnRef
- | Rollup [AggregateBitKey]
- | Cube [AggregateBitKey]
- | GroupingSets [AggregateSet]
newtype AggregateKey a = AggregateKey (a, AggregateElem)
data NodeAttr
- = Just'
- | Maybe
data ProductTree rs
- = Leaf (Bool, Qualified SubQuery)
- | Join !(Node rs) !(Node rs) !rs
data Node rs = Node !NodeAttr !(ProductTree rs)
nodeAttr :: Node rs -> NodeAttr
nodeTree :: Node rs -> ProductTree rs
type JoinProduct = Maybe (ProductTree [Predicate Flat])
data CaseClause
- = CaseSearch WhenClauses
- | CaseSimple Tuple WhenClauses
data WhenClauses = WhenClauses [(Tuple, Tuple)] Tuple
data Column
- = RawColumn StringSQL
- | SubQueryRef (Qualified Int)
- | Scalar SubQuery
- | Case CaseClause Int
type Tuple = [Column]
tupleWidth :: Tuple -> Int
data Record c t
untypeRecord :: Record c t -> Tuple
record :: Tuple -> Record c t
type PI c a b = Record c a -> Record c b
recordWidth :: Record c r -> Int
typeFromRawColumns :: [StringSQL] -> Record c r
typeFromScalarSubQuery :: SubQuery -> Record c t
type Predicate c = Record c (Maybe Bool)
growProduct :: Maybe (Node (DList (Predicate Flat))) -> (NodeAttr, (Bool, Qualified SubQuery)) -> Node (DList (Predicate Flat))
restrictProduct :: Node (DList (Predicate Flat)) -> Predicate Flat -> Node (DList (Predicate Flat))
aggregateColumnRef :: AggregateColumnRef -> AggregateElem
aggregatePowerKey :: [AggregateColumnRef] -> AggregateBitKey
aggregateGroupingSet :: [AggregateElem] -> AggregateSet
aggregateRollup :: [AggregateBitKey] -> AggregateElem
aggregateCube :: [AggregateBitKey] -> AggregateElem
aggregateSets :: [AggregateSet] -> AggregateElem
aggregateKeyRecord :: AggregateKey a -> a
aggregateKeyElement :: AggregateKey a -> AggregateElem
unsafeAggregateKey :: (a, AggregateElem) -> AggregateKey a
flatSubQuery :: Config -> Tuple -> Duplication -> JoinProduct -> [Predicate Flat] -> [OrderingTerm] -> SubQuery
aggregatedSubQuery :: Config -> Tuple -> Duplication -> JoinProduct -> [Predicate Flat] -> [AggregateElem] -> [Predicate Aggregated] -> [OrderingTerm] -> SubQuery
union :: Duplication -> SubQuery -> SubQuery -> SubQuery
except :: Duplication -> SubQuery -> SubQuery -> SubQuery
intersect :: Duplication -> SubQuery -> SubQuery -> SubQuery
caseSearch :: [(Predicate c, Record c a)] -> Record c a -> Record c a
case' :: Record c a -> [(Record c a, Record c b)] -> Record c b -> Record c b
showSQL :: SubQuery -> StringSQL
toSQL :: SubQuery -> String
unitSQL :: SubQuery -> String
width :: SubQuery -> Int
queryWidth :: Qualified SubQuery -> Int
corrSubQueryTerm :: Bool -> Qualified SubQuery -> StringSQL
column :: Qualified SubQuery -> Int -> StringSQL
tupleFromJoinedSubQuery :: Qualified SubQuery -> Tuple
recordRawColumns :: Record c r -> [StringSQL]
composeWhere :: [Predicate Flat] -> StringSQL
composeHaving :: [Predicate Aggregated] -> StringSQL
composeGroupBy :: [AggregateElem] -> StringSQL
composePartitionBy :: [AggregateColumnRef] -> StringSQL
composeOrderBy :: [OrderingTerm] -> StringSQL
type AssignColumn = StringSQL
type AssignTerm = StringSQL
type Assignment = (AssignColumn, AssignTerm)
composeSets :: [Assignment] -> StringSQL
composeChunkValues :: Int -> [AssignTerm] -> Keyword
composeChunkValuesWithColumns :: Int -> [Assignment] -> StringSQL
composeValuesListWithColumns :: [[Assignment]] -> StringSQL

The SubQuery

data SubQuery Source #

Sub-query type

Constructors

Table Untyped
Flat Config Tuple Duplication JoinProduct [Predicate Flat] [OrderingTerm]
Aggregated Config Tuple Duplication JoinProduct [Predicate Flat] [AggregateElem] [Predicate Aggregated] [OrderingTerm]
Bin BinOp SubQuery SubQuery

Instances

Instances details

Show SubQuery Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> SubQuery -> ShowS # show :: SubQuery -> String # showList :: [SubQuery] -> ShowS #

Set operations

data Duplication Source #

Result record duplication attribute

Constructors

All
Distinct

Instances

Instances details

Show Duplication Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> Duplication -> ShowS # show :: Duplication -> String # showList :: [Duplication] -> ShowS #

data SetOp Source #

Set operators

Constructors

Union
Except
Intersect

Instances

Instances details

Show SetOp Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> SetOp -> ShowS # show :: SetOp -> String # showList :: [SetOp] -> ShowS #

newtype BinOp Source #

Set binary operators

Constructors

BinOp (SetOp, Duplication)

Instances

Instances details

Show BinOp Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> BinOp -> ShowS # show :: BinOp -> String # showList :: [BinOp] -> ShowS #

Qualifiers for nested query

newtype Qualifier Source #

Qualifier type.

Constructors

Qualifier Int

Instances

Instances details

Show Qualifier Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> Qualifier -> ShowS # show :: Qualifier -> String # showList :: [Qualifier] -> ShowS #

data Qualified a Source #

Qualified query.

Constructors

Qualified Qualifier a

Instances

Instances details

Foldable Qualified Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods fold :: Monoid m => Qualified m -> m # foldMap :: Monoid m => (a -> m) -> Qualified a -> m # foldMap' :: Monoid m => (a -> m) -> Qualified a -> m # foldr :: (a -> b -> b) -> b -> Qualified a -> b # foldr' :: (a -> b -> b) -> b -> Qualified a -> b # foldl :: (b -> a -> b) -> b -> Qualified a -> b # foldl' :: (b -> a -> b) -> b -> Qualified a -> b # foldr1 :: (a -> a -> a) -> Qualified a -> a # foldl1 :: (a -> a -> a) -> Qualified a -> a # toList :: Qualified a -> [a] # null :: Qualified a -> Bool # length :: Qualified a -> Int # elem :: Eq a => a -> Qualified a -> Bool # maximum :: Ord a => Qualified a -> a # minimum :: Ord a => Qualified a -> a # sum :: Num a => Qualified a -> a # product :: Num a => Qualified a -> a #
Traversable Qualified Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods traverse :: Applicative f => (a -> f b) -> Qualified a -> f (Qualified b) # sequenceA :: Applicative f => Qualified (f a) -> f (Qualified a) # mapM :: Monad m => (a -> m b) -> Qualified a -> m (Qualified b) # sequence :: Monad m => Qualified (m a) -> m (Qualified a) #
Functor Qualified Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods fmap :: (a -> b) -> Qualified a -> Qualified b # (<$) :: a -> Qualified b -> Qualified a #
Show a => Show (Qualified a) Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> Qualified a -> ShowS # show :: Qualified a -> String # showList :: [Qualified a] -> ShowS #

qualifier :: Qualified a -> Qualifier Source #

Get qualifier

unQualify :: Qualified a -> a Source #

Unqualify.

qualify :: Qualifier -> a -> Qualified a Source #

Add qualifier

Ordering types

data Order Source #

Order direction. Ascendant or Descendant.

Constructors

Asc
Desc

Instances

Instances details

Show Order Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> Order -> ShowS # show :: Order -> String # showList :: [Order] -> ShowS #

data Nulls Source #

Order of null.

Constructors

NullsFirst
NullsLast

Instances

Instances details

Show Nulls Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> Nulls -> ShowS # show :: Nulls -> String # showList :: [Nulls] -> ShowS #

type OrderColumn = Column Source #

Type for order-by column

type OrderingTerm = ((Order, Maybe Nulls), OrderColumn) Source #

Type for order-by term

Aggregating types

type AggregateColumnRef = Column Source #

Type for group-by term

newtype AggregateBitKey Source #

Type for group key.

Constructors

AggregateBitKey [AggregateColumnRef]

Instances

Instances details

Show AggregateBitKey Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> AggregateBitKey -> ShowS # show :: AggregateBitKey -> String # showList :: [AggregateBitKey] -> ShowS #

newtype AggregateSet Source #

Type for grouping set

Constructors

AggregateSet [AggregateElem]

Instances

Instances details

Show AggregateSet Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> AggregateSet -> ShowS # show :: AggregateSet -> String # showList :: [AggregateSet] -> ShowS #

data AggregateElem Source #

Type for group-by tree

Constructors

ColumnRef AggregateColumnRef
Rollup [AggregateBitKey]
Cube [AggregateBitKey]
GroupingSets [AggregateSet]

Instances

Instances details

Show AggregateElem Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> AggregateElem -> ShowS # show :: AggregateElem -> String # showList :: [AggregateElem] -> ShowS #
MonadQualify q m => MonadQualify q (AggregatingSetT m) Source #	Aggregated `MonadQualify`.
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods liftQualify :: q a -> AggregatingSetT m a Source #
MonadRestrict c m => MonadRestrict c (AggregatingSetT m) Source #	Aggregated `MonadRestrict`.
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods restrict :: Predicate c -> AggregatingSetT m () Source #
MonadQuery m => MonadAggregate (AggregatingSetT m) Source #	Aggregated query instance.
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods groupBy :: Record Flat r -> AggregatingSetT m (Record Aggregated r) Source # groupBy' :: AggregateKey (Record Aggregated r) -> AggregatingSetT m (Record Aggregated r) Source #
MonadQuery m => MonadQuery (AggregatingSetT m) Source #	Aggregated `MonadQuery`.
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods setDuplication :: Duplication -> AggregatingSetT m () Source # restrictJoin :: Predicate Flat -> AggregatingSetT m () Source # query' :: Relation p r -> AggregatingSetT m (PlaceHolders p, Record Flat r) Source # queryMaybe' :: Relation p r -> AggregatingSetT m (PlaceHolders p, Record Flat (Maybe r)) Source #

newtype AggregateKey a Source #

Typeful aggregate element.

Constructors

AggregateKey (a, AggregateElem)

Product tree type

data NodeAttr Source #

node attribute for product.

Constructors

Just'
Maybe

Instances

Instances details

Show NodeAttr Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> NodeAttr -> ShowS # show :: NodeAttr -> String # showList :: [NodeAttr] -> ShowS #

data ProductTree rs Source #

Product tree type. Product tree is constructed by left node and right node.

Constructors

Leaf (Bool, Qualified SubQuery)
Join !(Node rs) !(Node rs) !rs

Instances

Instances details

Functor ProductTree Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods fmap :: (a -> b) -> ProductTree a -> ProductTree b # (<$) :: a -> ProductTree b -> ProductTree a #
Show rs => Show (ProductTree rs) Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> ProductTree rs -> ShowS # show :: ProductTree rs -> String # showList :: [ProductTree rs] -> ShowS #

data Node rs Source #

Product node. node attribute and product tree.

Constructors

Node !NodeAttr !(ProductTree rs)

Instances

Instances details

Functor Node Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods fmap :: (a -> b) -> Node a -> Node b # (<$) :: a -> Node b -> Node a #
Show rs => Show (Node rs) Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> Node rs -> ShowS # show :: Node rs -> String # showList :: [Node rs] -> ShowS #

nodeAttr :: Node rs -> NodeAttr Source #

Get node attribute.

nodeTree :: Node rs -> ProductTree rs Source #

Get tree from node.

type JoinProduct = Maybe (ProductTree [Predicate Flat]) Source #

Type for join product of query.

Case

data CaseClause Source #

case clause

Constructors

CaseSearch WhenClauses
CaseSimple Tuple WhenClauses

Instances

Instances details

Show CaseClause Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> CaseClause -> ShowS # show :: CaseClause -> String # showList :: [CaseClause] -> ShowS #

data WhenClauses Source #

when clauses

Constructors

WhenClauses [(Tuple, Tuple)] Tuple

Instances

Instances details

Show WhenClauses Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> WhenClauses -> ShowS # show :: WhenClauses -> String # showList :: [WhenClauses] -> ShowS #

Column, Tuple, Record and Projection

data Column Source #

Projected column structure unit with single column width

Constructors

RawColumn StringSQL	used in immediate value or unsafe operations
SubQueryRef (Qualified Int)	normalized sub-query reference Tn with Int index
Scalar SubQuery	scalar sub-query
Case CaseClause Int	nth column of case clause

Instances

Instances details

Show Column Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> Column -> ShowS # show :: Column -> String # showList :: [Column] -> ShowS #
Monad m => MonadPartition c (PartitioningSetT c m) Source #	Partition clause instance
Instance details Defined in Database.Relational.Monad.Trans.Aggregating Methods partitionBy :: Record c r -> PartitioningSetT c m () Source #

type Tuple = [Column] Source #

Untyped projected tuple. Forgot record type.

tupleWidth :: Tuple -> Int Source #

Width of Tuple.

data Record c t Source #

Phantom typed record. Projected into Haskell record type t.

Instances

Instances details

(PersistableWidth a, HasProjection l a b) => IsLabel l (PI c a b) Source #	Derive `PI` label.
Instance details Defined in Database.Relational.OverloadedProjection Methods fromLabel :: PI c a b #
ProductIsoApplicative (Record c) Source #	Compose `Record` using applicative style.
Instance details Defined in Database.Relational.Record Methods pureP :: ProductConstructor a => a -> Record c a # (\|*\|) :: Record c (a -> b) -> Record c a -> Record c b #
ProductIsoFunctor (Record c) Source #	Map `Record` which result type is record.
Instance details Defined in Database.Relational.Record Methods (\|$\|) :: ProductConstructor (a -> b) => (a -> b) -> Record c a -> Record c b #
ProjectableMaybe (Record c) Source #	Control phantom `Maybe` type in record type `Record`.
Instance details Defined in Database.Relational.Projectable Methods just :: Record c a -> Record c (Maybe a) Source # flattenMaybe :: Record c (Maybe (Maybe a)) -> Record c (Maybe a) Source #
ProductIsoEmpty (Record c) () Source #
Instance details Defined in Database.Relational.Record Methods pureE :: Record c () # peRight :: Record c (a, ()) -> Record c a # peLeft :: Record c ((), a) -> Record c a #
Show (Record c t) Source #
Instance details Defined in Database.Relational.SqlSyntax.Types Methods showsPrec :: Int -> Record c t -> ShowS # show :: Record c t -> String # showList :: [Record c t] -> ShowS #
TableDerivable r => Show (Record Flat r -> Assign r (PlaceHolders p)) Source #	Show Set clause and WHERE clause.
Instance details Defined in Database.Relational.Effect Methods showsPrec :: Int -> (Record Flat r -> Assign r (PlaceHolders p)) -> ShowS # show :: (Record Flat r -> Assign r (PlaceHolders p)) -> String # showList :: [Record Flat r -> Assign r (PlaceHolders p)] -> ShowS #
TableDerivable r => Show (Record Flat r -> Restrict (PlaceHolders p)) Source #	Show WHERE clause.
Instance details Defined in Database.Relational.Effect Methods showsPrec :: Int -> (Record Flat r -> Restrict (PlaceHolders p)) -> ShowS # show :: (Record Flat r -> Restrict (PlaceHolders p)) -> String # showList :: [Record Flat r -> Restrict (PlaceHolders p)] -> ShowS #

untypeRecord :: Record c t -> Tuple Source #

Discard record type

record :: Tuple -> Record c t Source #

Unsafely type Tuple value to Record type.

type PI c a b = Record c a -> Record c b Source #

Type for projection function.

recordWidth :: Record c r -> Int Source #

Width of Record.

typeFromRawColumns Source #

Arguments

:: [StringSQL]	SQL string list specifies columns
-> Record c r	Result `Record`

Unsafely generate Record from SQL string list.

typeFromScalarSubQuery :: SubQuery -> Record c t Source #

Unsafely generate Record from scalar sub-query.

Predicate to restrict Query result

type Predicate c = Record c (Maybe Bool) Source #

Type for predicate to restrict of query result.

growProduct Source #

Arguments

:: Maybe (Node (DList (Predicate Flat)))	Current tree
-> (NodeAttr, (Bool, Qualified SubQuery))	New leaf to push into right
-> Node (DList (Predicate Flat))	Result node

Push new leaf node into product right term.

restrictProduct Source #

Arguments

:: Node (DList (Predicate Flat))	Target node which has product to restrict
-> Predicate Flat	Restriction to add
-> Node (DList (Predicate Flat))	Result node

Add restriction into top product of product tree node.

aggregateColumnRef :: AggregateColumnRef -> AggregateElem Source #

Single term aggregation element.

aggregatePowerKey :: [AggregateColumnRef] -> AggregateBitKey Source #

Key of aggregation power set.

aggregateGroupingSet :: [AggregateElem] -> AggregateSet Source #

Single grouping set.

aggregateRollup :: [AggregateBitKey] -> AggregateElem Source #

Rollup aggregation element.

aggregateCube :: [AggregateBitKey] -> AggregateElem Source #

Cube aggregation element.

aggregateSets :: [AggregateSet] -> AggregateElem Source #

Grouping sets aggregation.

aggregateKeyRecord :: AggregateKey a -> a Source #

Extract typed record from AggregateKey.

aggregateKeyElement :: AggregateKey a -> AggregateElem Source #

Extract untyped term from AggregateKey.

unsafeAggregateKey :: (a, AggregateElem) -> AggregateKey a Source #

Unsafely bind typed-record and untyped-term into AggregateKey.

flatSubQuery :: Config -> Tuple -> Duplication -> JoinProduct -> [Predicate Flat] -> [OrderingTerm] -> SubQuery Source #

Unsafely generate flat SubQuery from untyped components.

aggregatedSubQuery :: Config -> Tuple -> Duplication -> JoinProduct -> [Predicate Flat] -> [AggregateElem] -> [Predicate Aggregated] -> [OrderingTerm] -> SubQuery Source #

Unsafely generate aggregated SubQuery from untyped components.

union :: Duplication -> SubQuery -> SubQuery -> SubQuery Source #

Union binary operator on SubQuery

except :: Duplication -> SubQuery -> SubQuery -> SubQuery Source #

Except binary operator on SubQuery

intersect :: Duplication -> SubQuery -> SubQuery -> SubQuery Source #

Intersect binary operator on SubQuery

caseSearch Source #

Arguments

:: [(Predicate c, Record c a)]	Each when clauses
-> Record c a	Else result record
-> Record c a	Result record

Search case operator correnponding SQL search CASE. Like, CASE WHEN p0 THEN a WHEN p1 THEN b ... ELSE c END

case' Source #

Arguments

:: Record c a	Record value to match
-> [(Record c a, Record c b)]	Each when clauses
-> Record c b	Else result record
-> Record c b	Result record

Simple case operator correnponding SQL simple CASE. Like, CASE x WHEN v THEN a WHEN w THEN b ... ELSE c END

Sub-query

showSQL :: SubQuery -> StringSQL Source #

SQL StringSQL for toplevel-SQL.

toSQL :: SubQuery -> String Source #

SQL string for toplevel-SQL.

unitSQL :: SubQuery -> String Source #

SQL string for nested-qeury.

width :: SubQuery -> Int Source #

Width of SubQuery.

Qualified Sub-query

queryWidth :: Qualified SubQuery -> Int Source #

Width of Qualified SubQUery.

corrSubQueryTerm Source #

Arguments

:: Bool	if True, add AS keyword. SQLite causes syntax error on UPDATE or DELETE statement.
-> Qualified SubQuery	subquery structure with qualifier
-> StringSQL	result SQL string

Term of qualified table or qualified subquery, used in join-clause of SELECT, correlated UPDATE and DELETE statements. When SubQuery is table, expression will be like TABLE [AS] Tn