Database.Relational.SqlSyntax

This module is integrated module of sql-syntax.

The SubQuery

data SubQuery

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

Show SubQuery

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> SubQuery -> ShowS

show :: SubQuery -> String

showList :: [SubQuery] -> ShowS

Set operations

data Duplication

Result record duplication attribute

Constructors

All

Distinct

Instances

Show Duplication

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> Duplication -> ShowS

show :: Duplication -> String

showList :: [Duplication] -> ShowS

data SetOp

Set operators

Constructors

Union

Except

Intersect

Instances

Show SetOp

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> SetOp -> ShowS

show :: SetOp -> String

showList :: [SetOp] -> ShowS

newtype BinOp

Set binary operators

Constructors

BinOp (SetOp, Duplication)

Instances

Show BinOp

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> BinOp -> ShowS

show :: BinOp -> String

showList :: [BinOp] -> ShowS

Qualifiers for nested query

newtype Qualifier

Qualifier type.

Constructors

Qualifier Int

Instances

Show Qualifier

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> Qualifier -> ShowS

show :: Qualifier -> String

showList :: [Qualifier] -> ShowS

data Qualified a

Qualified query.

Constructors

Qualified Qualifier a

Instances

Functor Qualified

Defined in Database.Relational.SqlSyntax.Types

Methods

fmap :: (a -> b) -> Qualified a -> Qualified b

(<$) :: a -> Qualified b -> Qualified a

Foldable Qualified

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

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)

Show a => Show (Qualified a)

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> Qualified a -> ShowS

show :: Qualified a -> String

showList :: [Qualified a] -> ShowS

qualifier :: Qualified a -> Qualifier

Get qualifier

unQualify :: Qualified a -> a

Unqualify.

qualify :: Qualifier -> a -> Qualified a

Add qualifier

Ordering types

data Order

Order direction. Ascendant or Descendant.

Constructors

Asc

Desc

Instances

Show Order

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> Order -> ShowS

show :: Order -> String

showList :: [Order] -> ShowS

data Nulls

Order of null.

Constructors

NullsFirst

NullsLast

Instances

Show Nulls

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> Nulls -> ShowS

show :: Nulls -> String

showList :: [Nulls] -> ShowS

type OrderColumn = Column

Type for order-by column

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

Type for order-by term

Aggregating types

type AggregateColumnRef = Column

Type for group-by term

newtype AggregateBitKey

Type for group key.

Constructors

AggregateBitKey [AggregateColumnRef]

Instances

Show AggregateBitKey

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> AggregateBitKey -> ShowS

show :: AggregateBitKey -> String

showList :: [AggregateBitKey] -> ShowS

newtype AggregateSet

Type for grouping set

Constructors

AggregateSet [AggregateElem]

Instances

Show AggregateSet

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> AggregateSet -> ShowS

show :: AggregateSet -> String

showList :: [AggregateSet] -> ShowS

data AggregateElem

Type for group-by tree

Constructors

ColumnRef AggregateColumnRef

Rollup [AggregateBitKey]

Cube [AggregateBitKey]

GroupingSets [AggregateSet]

Instances

Show AggregateElem

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> AggregateElem -> ShowS

show :: AggregateElem -> String

showList :: [AggregateElem] -> ShowS

MonadQualify q m => MonadQualify q (AggregatingSetT m)

Aggregated MonadQualify.

Defined in Database.Relational.Monad.Trans.Aggregating

Methods

liftQualify :: q a -> AggregatingSetT m a

MonadRestrict c m => MonadRestrict c (AggregatingSetT m)

Aggregated MonadRestrict.

Defined in Database.Relational.Monad.Trans.Aggregating

Methods

restrict :: Predicate c -> AggregatingSetT m ()

MonadQuery m => MonadAggregate (AggregatingSetT m)

Aggregated query instance.

Defined in Database.Relational.Monad.Trans.Aggregating

Methods

groupBy :: Record Flat r -> AggregatingSetT m (Record Aggregated r)

groupBy' :: AggregateKey (Record Aggregated r) -> AggregatingSetT m (Record Aggregated r)

MonadQuery m => MonadQuery (AggregatingSetT m)

Aggregated MonadQuery.

Defined in Database.Relational.Monad.Trans.Aggregating

Methods

setDuplication :: Duplication -> AggregatingSetT m ()

restrictJoin :: Predicate Flat -> AggregatingSetT m ()

query' :: Relation p r -> AggregatingSetT m (PlaceHolders p, Record Flat r)

queryMaybe' :: Relation p r -> AggregatingSetT m (PlaceHolders p, Record Flat (Maybe r))

newtype AggregateKey a

Typeful aggregate element.

Constructors

AggregateKey (a, AggregateElem)

Product tree type

data NodeAttr

node attribute for product.

Constructors

Just'

Maybe

Instances

Show NodeAttr

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> NodeAttr -> ShowS

show :: NodeAttr -> String

showList :: [NodeAttr] -> ShowS

data ProductTree rs

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

Functor ProductTree

Defined in Database.Relational.SqlSyntax.Types

Methods

fmap :: (a -> b) -> ProductTree a -> ProductTree b

(<$) :: a -> ProductTree b -> ProductTree a

Show rs => Show (ProductTree rs)

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> ProductTree rs -> ShowS

show :: ProductTree rs -> String

showList :: [ProductTree rs] -> ShowS

data Node rs

Product node. node attribute and product tree.

Constructors

Node !NodeAttr !(ProductTree rs)

Instances

Functor Node

Defined in Database.Relational.SqlSyntax.Types

Methods

fmap :: (a -> b) -> Node a -> Node b

(<$) :: a -> Node b -> Node a

Show rs => Show (Node rs)

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> Node rs -> ShowS

show :: Node rs -> String

showList :: [Node rs] -> ShowS

nodeAttr :: Node rs -> NodeAttr

Get node attribute.

nodeTree :: Node rs -> ProductTree rs

Get tree from node.

type JoinProduct = Maybe (ProductTree [Predicate Flat])

Type for join product of query.

Case

data CaseClause

case clause

Constructors

CaseSearch WhenClauses

CaseSimple Tuple WhenClauses

Instances

Show CaseClause

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> CaseClause -> ShowS

show :: CaseClause -> String

showList :: [CaseClause] -> ShowS

data WhenClauses

when clauses

Constructors

WhenClauses [(Tuple, Tuple)] Tuple

Instances

Show WhenClauses

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> WhenClauses -> ShowS

show :: WhenClauses -> String

showList :: [WhenClauses] -> ShowS

Column, Tuple, Record and Projection

data Column

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

Show Column

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> Column -> ShowS

show :: Column -> String

showList :: [Column] -> ShowS

Monad m => MonadPartition c (PartitioningSetT c m)

Partition clause instance

Defined in Database.Relational.Monad.Trans.Aggregating

Methods

partitionBy :: Record c r -> PartitioningSetT c m ()

type Tuple = [Column]

Untyped projected tuple. Forgot record type.

tupleWidth :: Tuple -> Int

Width of Tuple.

data Record c t

Phantom typed record. Projected into Haskell record type t.

Instances

(PersistableWidth a, HasProjection l a b) => IsLabel l (PI c a b)

Derive PI label.

Defined in Database.Relational.OverloadedProjection

Methods

fromLabel :: PI c a b

ProductIsoFunctor (Record c)

Map Record which result type is record.

Defined in Database.Relational.Record

Methods

(|$|) :: ProductConstructor (a -> b) => (a -> b) -> Record c a -> Record c b

ProductIsoApplicative (Record c)

Compose Record using applicative style.

Defined in Database.Relational.Record

Methods

pureP :: ProductConstructor a => a -> Record c a

(|*|) :: Record c (a -> b) -> Record c a -> Record c b

ProjectableMaybe (Record c)

Control phantom Maybe type in record type Record.

Defined in Database.Relational.Projectable

Methods

just :: Record c a -> Record c (Maybe a)

flattenMaybe :: Record c (Maybe (Maybe a)) -> Record c (Maybe a)

ProductIsoEmpty (Record c) ()

Defined in Database.Relational.Record

Methods

pureE :: Record c ()

peRight :: Record c (a, ()) -> Record c a

peLeft :: Record c ((), a) -> Record c a

TableDerivable r => Show (Record Flat r -> Assign r (PlaceHolders p))

Show Set clause and WHERE clause.

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

Show WHERE clause.

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

Show (Record c t)

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> Record c t -> ShowS

show :: Record c t -> String

showList :: [Record c t] -> ShowS

untypeRecord :: Record c t -> Tuple

Discard record type

record :: Tuple -> Record c t

Unsafely type Tuple value to Record type.

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

Type for projection function.

recordWidth :: Record c r -> Int

Width of Record.

typeFromRawColumns

Arguments

:: [StringSQL]

SQL string list specifies columns

-> Record c r

Result Record

Unsafely generate Record from SQL string list.

typeFromScalarSubQuery :: SubQuery -> Record c t

Unsafely generate Record from scalar sub-query.

Predicate to restrict Query result

type Predicate c = Record c (Maybe Bool)

Type for predicate to restrict of query result.

growProduct

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

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

Single term aggregation element.

aggregatePowerKey :: [AggregateColumnRef] -> AggregateBitKey

Key of aggregation power set.

aggregateGroupingSet :: [AggregateElem] -> AggregateSet

Single grouping set.

aggregateRollup :: [AggregateBitKey] -> AggregateElem

Rollup aggregation element.

aggregateCube :: [AggregateBitKey] -> AggregateElem

Cube aggregation element.

aggregateSets :: [AggregateSet] -> AggregateElem

Grouping sets aggregation.

aggregateKeyRecord :: AggregateKey a -> a

Extract typed record from AggregateKey.

aggregateKeyElement :: AggregateKey a -> AggregateElem

Extract untyped term from AggregateKey.

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

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

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

Unsafely generate flat SubQuery from untyped components.

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

Unsafely generate aggregated SubQuery from untyped components.

union :: Duplication -> SubQuery -> SubQuery -> SubQuery

Union binary operator on SubQuery

except :: Duplication -> SubQuery -> SubQuery -> SubQuery

Except binary operator on SubQuery

intersect :: Duplication -> SubQuery -> SubQuery -> SubQuery

Intersect binary operator on SubQuery

caseSearch

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'

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

SQL StringSQL for toplevel-SQL.

toSQL :: SubQuery -> String

SQL string for toplevel-SQL.

unitSQL :: SubQuery -> String

SQL string for nested-qeury.

width :: SubQuery -> Int

Width of SubQuery.

Qualified Sub-query

queryWidth :: Qualified SubQuery -> Int

Width of Qualified SubQUery.

corrSubQueryTerm

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

Sub-query columns

column :: Qualified SubQuery -> Int -> StringSQL

Get column SQL string of Qualified SubQuery.

Tuple and Record

tupleFromJoinedSubQuery :: Qualified SubQuery -> Tuple

Make untyped tuple (qualified column list) from joined sub-query (Qualified SubQuery).

recordRawColumns

Arguments

:: Record c r

Source Record

-> [StringSQL]

Result SQL string list

Get column SQL string list of record.

Query restriction

composeWhere :: [Predicate Flat] -> StringSQL

Compose WHERE clause from QueryRestriction.

composeHaving :: [Predicate Aggregated] -> StringSQL

Compose HAVING clause from QueryRestriction.

Aggregation

composeGroupBy :: [AggregateElem] -> StringSQL

Compose GROUP BY clause from AggregateElem list.

composePartitionBy :: [AggregateColumnRef] -> StringSQL

Compose PARTITION BY clause from AggregateColumnRef list.

Ordering

composeOrderBy :: [OrderingTerm] -> StringSQL

Compose ORDER BY clause from OrderingTerms

Update and Insert assignments

type AssignColumn = StringSQL

Column SQL String of assignment

type AssignTerm = StringSQL

Value SQL String of assignment

type Assignment = (AssignColumn, AssignTerm)

Assignment pair

composeSets :: [Assignment] -> StringSQL

Compose SET clause from [Assignment].

composeChunkValues

Arguments

:: Int

record count per chunk

-> [AssignTerm]

value expression list

-> Keyword

Compose VALUES clause from a row of value expressions.

composeChunkValuesWithColumns

Arguments

:: Int

record count per chunk

-> [Assignment]

-> StringSQL

Compose columns row and VALUES clause from a row of value expressions.

composeValuesListWithColumns :: [[Assignment]] -> StringSQL

Compose columns row and VALUES clause from rows list of value expressions.