Database.Relational

This module is integrated module of Query.

Documentation

class PersistableWidth r => TableDerivable r where

Inference rule of Table existence.

Methods

derivedTable :: Table r

data Table r

Phantom typed table type

Instances

Show (Table r)

Defined in Database.Relational.Table

Methods

showsPrec :: Int -> Table r -> ShowS

show :: Table r -> String

showList :: [Table r] -> ShowS

type QuerySuffix = [Keyword]

Type for query suffix words

updateOtherThanKeySQL

Arguments

:: Table r

Table metadata

-> Pi r p

Key columns

-> String

Result SQL

Generate update SQL specified by single key.

module Database.Relational.Pi

data Unique

Constraint type. Unique key.

data NotNull

Constraint type. Not-null key.

Instances

HasColumnConstraint NotNull a => HasColumnConstraint NotNull (a, b)

Inference rule of ColumnConstraint NotNull for tuple (,) type.

Defined in Database.Record.KeyConstraint

Methods

columnConstraint :: ColumnConstraint NotNull (a, b)

data Primary

Constraint type. Primary key.

class PersistableWidth ct => HasConstraintKey c r ct where

Constraint Key inference interface.

Methods

constraintKey :: Key c r ct

Infer constraint key.

data Key c r ct

Constraint Key proof object. Constraint type c, record type r and columns type ct.

tableConstraint :: Key c r ct -> KeyConstraint c r

Get table constraint KeyConstraint proof object from constraint Key.

projectionKey :: Key c r ct -> Pi r ct

Get projection path proof object from constraint Key.

uniqueKey :: PersistableWidth ct => Key Primary r ct -> Key Unique r ct

Derive Unique constraint Key from Primary constraint Key

derivedUniqueKey :: HasConstraintKey Primary r ct => Key Unique r ct

Inferred Unique constraint Key. Record type r has unique key which type is ct derived from primay key.

module Database.Relational.Context

module Database.Relational.Config

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

Type for projection function.

type Predicate c = Record c (Maybe Bool)

Type for predicate to restrict of query result.

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

data SubQuery

Sub-query type

Instances

Show SubQuery

Defined in Database.Relational.SqlSyntax.Types

Methods

showsPrec :: Int -> SubQuery -> ShowS

show :: SubQuery -> String

showList :: [SubQuery] -> ShowS

data AggregateKey a

Typeful aggregate element.

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

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

queryWidth :: Qualified SubQuery -> Int

Width of Qualified SubQUery.

unitSQL :: SubQuery -> String

SQL string for nested-qeury.

data RecordList p t

Projected record list type for row list.

list :: [p t] -> RecordList p t

Make projected record list from Record list.

module Database.Relational.ProjectableClass

module Database.Relational.Projectable

module Database.Relational.TupleInstances

module Database.Relational.Monad.BaseType

class Monad m => MonadPartition c m where

Window specification building interface.

Methods

partitionBy :: Record c r -> m ()

Add PARTITION BY term into context.

Instances

MonadPartition c m => MonadPartition c (Orderings c m)

MonadPartition with ordering.

Defined in Database.Relational.Monad.Trans.Ordering

Methods

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

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

class MonadQuery m => MonadAggregate m where

Aggregated query building interface extends MonadQuery.

Methods

groupBy

Arguments

:: Record Flat r

Record to add into group by

-> m (Record Aggregated r)

Result context and aggregated record | Add GROUP BY term into context and get aggregated record. Non-traditional group-by version.

Add GROUP BY term into context and get aggregated record.

groupBy'

Arguments

:: AggregateKey (Record Aggregated r)

Key to aggretate for non-traditional group-by interface

-> m (Record Aggregated r)

Result context and aggregated record

Instances

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)

MonadAggregate m => MonadAggregate (Restrictings c m)

Resticted MonadAggregate instance.

Defined in Database.Relational.Monad.Trans.Restricting

Methods

groupBy :: Record Flat r -> Restrictings c m (Record Aggregated r)

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

MonadAggregate m => MonadAggregate (Orderings c m)

MonadAggregate with ordering.

Defined in Database.Relational.Monad.Trans.Ordering

Methods

groupBy :: Record Flat r -> Orderings c m (Record Aggregated r)

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

class (Functor q, Monad q, Functor m, Monad m) => MonadQualify q m

Lift interface from base qualify monad.

Minimal complete definition

liftQualify

Instances

(Functor q, Monad q) => MonadQualify q q

Defined in Database.Relational.Monad.Class

Methods

liftQualify :: q a -> q a

MonadQualify ConfigureQuery QueryUnique

Defined in Database.Relational.Monad.Unique

Methods

liftQualify :: ConfigureQuery a -> QueryUnique a

MonadQualify q m => MonadQualify q (QueryJoin m)

Defined in Database.Relational.Monad.Trans.Join

Methods

liftQualify :: q a -> QueryJoin m a

MonadQualify q m => MonadQualify q (AggregatingSetT m)

Aggregated MonadQualify.

Defined in Database.Relational.Monad.Trans.Aggregating

Methods

liftQualify :: q a -> AggregatingSetT m a

MonadQualify q m => MonadQualify q (Restrictings c m)

Restricted MonadQualify instance.

Defined in Database.Relational.Monad.Trans.Restricting

Methods

liftQualify :: q a -> Restrictings c m a

MonadQualify q m => MonadQualify q (Orderings c m)

MonadQualify with ordering.

Defined in Database.Relational.Monad.Trans.Ordering

Methods

liftQualify :: q a -> Orderings c m a

MonadQualify q m => MonadQualify q (Assignings r m)

MonadQualify with assigning.

Defined in Database.Relational.Monad.Trans.Assigning

Methods

liftQualify :: q a -> Assignings r m a

class (Functor m, Monad m, MonadQualify ConfigureQuery m) => MonadQuery m where

Query building interface.

Minimal complete definition

setDuplication, restrictJoin, query', queryMaybe'

Methods

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

Join sub-query with place-holder parameter p. query result is not Maybe.

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

Join sub-query with place-holder parameter p. Query result is Maybe.

Instances

MonadQuery QueryUnique

Defined in Database.Relational.Monad.Unique

Methods

setDuplication :: Duplication -> QueryUnique ()

restrictJoin :: Predicate Flat -> QueryUnique ()

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

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

MonadQuery (QueryJoin ConfigureQuery)

Joinable query instance.

Defined in Database.Relational.Monad.Trans.Join

Methods

setDuplication :: Duplication -> QueryJoin ConfigureQuery ()

restrictJoin :: Predicate Flat -> QueryJoin ConfigureQuery ()

query' :: Relation p r -> QueryJoin ConfigureQuery (PlaceHolders p, Record Flat r)

queryMaybe' :: Relation p r -> QueryJoin ConfigureQuery (PlaceHolders p, Record Flat (Maybe 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))

MonadQuery q => MonadQuery (Restrictings c q)

Restricted MonadQuery instance.

Defined in Database.Relational.Monad.Trans.Restricting

Methods

setDuplication :: Duplication -> Restrictings c q ()

restrictJoin :: Predicate Flat -> Restrictings c q ()

query' :: Relation p r -> Restrictings c q (PlaceHolders p, Record Flat r)

queryMaybe' :: Relation p r -> Restrictings c q (PlaceHolders p, Record Flat (Maybe r))

MonadQuery m => MonadQuery (Orderings c m)

MonadQuery with ordering.

Defined in Database.Relational.Monad.Trans.Ordering

Methods

setDuplication :: Duplication -> Orderings c m ()

restrictJoin :: Predicate Flat -> Orderings c m ()

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

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

class (Functor m, Monad m) => MonadRestrict c m where

Restrict context interface

Methods

restrict

Arguments

:: Predicate c

Record which represent restriction

-> m ()

Restricted query context

Add restriction to this context.

Instances

MonadRestrict c m => MonadRestrict c (AggregatingSetT m)

Aggregated MonadRestrict.

Defined in Database.Relational.Monad.Trans.Aggregating

Methods

restrict :: Predicate c -> AggregatingSetT m ()

(Monad q, Functor q) => MonadRestrict c (Restrictings c q)

MonadRestrict instance.

Defined in Database.Relational.Monad.Trans.Restricting

Methods

restrict :: Predicate c -> Restrictings c q ()

MonadRestrict rc m => MonadRestrict rc (Orderings c m)

MonadRestrict with ordering.

Defined in Database.Relational.Monad.Trans.Ordering

Methods

restrict :: Predicate rc -> Orderings c m ()

MonadRestrict c m => MonadRestrict c (Assignings r m)

MonadRestrict with assigning.

Defined in Database.Relational.Monad.Trans.Assigning

Methods

restrict :: Predicate c -> Assignings r m ()

MonadRestrict Flat q => MonadRestrict Flat (Restrictings Aggregated q)

Restricted MonadRestrict instance.

Defined in Database.Relational.Monad.Aggregate

Methods

restrict :: Predicate Flat -> Restrictings Aggregated q ()

all' :: MonadQuery m => m ()

Specify ALL attribute to query context.

distinct :: MonadQuery m => m ()

Specify DISTINCT attribute to query context.

on :: MonadQuery m => Predicate Flat -> m ()

Add restriction to last join. Record type version.

wheres :: MonadRestrict Flat m => Predicate Flat -> m ()

Add restriction to this not aggregated query.

having :: MonadRestrict Aggregated m => Predicate Aggregated -> m ()

Add restriction to this aggregated query. Aggregated Record type version.

data Orderings c m a

Type to accumulate ordering context. Type c is ordering term record context type.

Instances

MonadPartition c m => MonadPartition c (Orderings c m)

MonadPartition with ordering.

Defined in Database.Relational.Monad.Trans.Ordering

Methods

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

MonadQualify q m => MonadQualify q (Orderings c m)

MonadQualify with ordering.

Defined in Database.Relational.Monad.Trans.Ordering

Methods

liftQualify :: q a -> Orderings c m a

MonadRestrict rc m => MonadRestrict rc (Orderings c m)

MonadRestrict with ordering.

Defined in Database.Relational.Monad.Trans.Ordering

Methods

restrict :: Predicate rc -> Orderings c m ()

MonadTrans (Orderings c)

Defined in Database.Relational.Monad.Trans.Ordering

Methods

lift :: Monad m => m a -> Orderings c m a

Monad m => Monad (Orderings c m)

Defined in Database.Relational.Monad.Trans.Ordering

Methods

(>>=) :: Orderings c m a -> (a -> Orderings c m b) -> Orderings c m b

(>>) :: Orderings c m a -> Orderings c m b -> Orderings c m b

return :: a -> Orderings c m a

fail :: String -> Orderings c m a

Functor m => Functor (Orderings c m)

Defined in Database.Relational.Monad.Trans.Ordering

Methods

fmap :: (a -> b) -> Orderings c m a -> Orderings c m b

(<$) :: a -> Orderings c m b -> Orderings c m a

Applicative m => Applicative (Orderings c m)

Defined in Database.Relational.Monad.Trans.Ordering

Methods

pure :: a -> Orderings c m a

(<*>) :: Orderings c m (a -> b) -> Orderings c m a -> Orderings c m b

liftA2 :: (a -> b -> c0) -> Orderings c m a -> Orderings c m b -> Orderings c m c0

(*>) :: Orderings c m a -> Orderings c m b -> Orderings c m b

(<*) :: Orderings c m a -> Orderings c m b -> Orderings c m a

MonadAggregate m => MonadAggregate (Orderings c m)

MonadAggregate with ordering.

Defined in Database.Relational.Monad.Trans.Ordering

Methods

groupBy :: Record Flat r -> Orderings c m (Record Aggregated r)

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

MonadQuery m => MonadQuery (Orderings c m)

MonadQuery with ordering.

Defined in Database.Relational.Monad.Trans.Ordering

Methods

setDuplication :: Duplication -> Orderings c m ()

restrictJoin :: Predicate Flat -> Orderings c m ()

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

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

orderBy'

Arguments

:: Monad m

=> Record c t

Ordering terms to add

-> Order

Order direction

-> Nulls

Order of null

-> Orderings c m ()

Result context with ordering

Add ordering terms with null ordering.

orderBy

Arguments

:: Monad m

=> Record c t

Ordering terms to add

-> Order

Order direction

-> Orderings c m ()

Result context with ordering

Add ordering terms.

asc

Arguments

:: Monad m

=> Record c t

Ordering terms to add

-> Orderings c m ()

Result context with ordering

Add ascendant ordering term.

desc

Arguments

:: Monad m

=> Record c t

Ordering terms to add

-> Orderings c m ()

Result context with ordering

Add descendant ordering term.

key :: Record Flat r -> AggregatingSet (Record Aggregated (Maybe r))

Specify key of single grouping set from Record.

key' :: AggregateKey a -> AggregatingSet a

Specify key of single grouping set.

set :: AggregatingSet a -> AggregatingSetList a

Finalize and specify single grouping set.

bkey :: Record Flat r -> AggregatingPowerSet (Record Aggregated (Maybe r))

Specify key of rollup and cube power set.

rollup :: AggregatingPowerSet a -> AggregateKey a

Finalize grouping power set as rollup power set.

cube :: AggregatingPowerSet a -> AggregateKey a

Finalize grouping power set as cube power set.

groupingSets :: AggregatingSetList a -> AggregateKey a

Finalize grouping set list.

assignTo :: Monad m => Record Flat v -> AssignTarget r v -> Assignings r m ()

Add an assignment.

(<-#) :: Monad m => AssignTarget r v -> Record Flat v -> Assignings r m () infix 4

Add and assginment.

module Database.Relational.Monad.Type

type SimpleQuery p r = OrderedQuery Flat QueryCore p r

Simple (not-aggregated) query type. SimpleQuery' p r == QuerySimple (PlaceHolders p, Record r).

type QuerySimple = Orderings Flat QueryCore

Simple (not-aggregated) query monad type.

type Window c = Orderings c (PartitioningSet c)

Partition monad type for partition-by clause.

type AggregatedQuery p r = OrderedQuery Aggregated (Restrictings Aggregated (AggregatingSetT QueryCore)) p r

Aggregated query type. AggregatedQuery p r == QueryAggregate (PlaceHolders p, Record Aggregated r).

type QueryAggregate = Orderings Aggregated (Restrictings Aggregated (AggregatingSetT QueryCore))

Aggregated query monad type.

over :: SqlContext c => Record OverWindow a -> Window c () -> Record c a infix 8

Operator to make record of window function result using built Window monad.

type Restrict = Restrictings Flat ConfigureQuery

Restrict only monad type used from update statement and delete statement.

data QueryUnique a

Unique query monad type.

Instances

Monad QueryUnique

Defined in Database.Relational.Monad.Unique

Methods

(>>=) :: QueryUnique a -> (a -> QueryUnique b) -> QueryUnique b

(>>) :: QueryUnique a -> QueryUnique b -> QueryUnique b

return :: a -> QueryUnique a

fail :: String -> QueryUnique a

Functor QueryUnique

Defined in Database.Relational.Monad.Unique

Methods

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

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

Applicative QueryUnique

Defined in Database.Relational.Monad.Unique

Methods

pure :: a -> QueryUnique a

(<*>) :: QueryUnique (a -> b) -> QueryUnique a -> QueryUnique b

liftA2 :: (a -> b -> c) -> QueryUnique a -> QueryUnique b -> QueryUnique c

(*>) :: QueryUnique a -> QueryUnique b -> QueryUnique b

(<*) :: QueryUnique a -> QueryUnique b -> QueryUnique a

MonadQuery QueryUnique

Defined in Database.Relational.Monad.Unique

Methods

setDuplication :: Duplication -> QueryUnique ()

restrictJoin :: Predicate Flat -> QueryUnique ()

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

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

MonadQualify ConfigureQuery QueryUnique

Defined in Database.Relational.Monad.Unique

Methods

liftQualify :: ConfigureQuery a -> QueryUnique a

type Assign r = Assignings r Restrict

Target update monad type used from update statement and merge statement.

type Register r = Assignings r ConfigureQuery

Target register monad type used from insert statement.

module Database.Relational.Relation

module Database.Relational.Set

module Database.Relational.Sequence

class PersistableWidth ct => ScalarDegree ct

Constraint which represents scalar degree.

Instances

ScalarDegree ct => ScalarDegree (Maybe ct)

Defined in Database.Relational.Scalar

class UntypeableNoFetch s where

Untype interface for typed no-result type statments with single type parameter which represents place-holder parameter p.

Methods

untypeNoFetch :: s p -> String

Instances

UntypeableNoFetch Delete

Defined in Database.Relational.Type

Methods

untypeNoFetch :: Delete p -> String

UntypeableNoFetch InsertQuery

Defined in Database.Relational.Type

Methods

untypeNoFetch :: InsertQuery p -> String

UntypeableNoFetch Insert

Defined in Database.Relational.Type

Methods

untypeNoFetch :: Insert p -> String

UntypeableNoFetch Update

Defined in Database.Relational.Type

Methods

untypeNoFetch :: Update p -> String

newtype Delete p

Delete type with place-holder parameter p.

Constructors

Delete

Fields

• untypeDelete :: String

Instances

UntypeableNoFetch Delete

Defined in Database.Relational.Type

Methods

untypeNoFetch :: Delete p -> String

Show (Delete p)

Show delete SQL string

Defined in Database.Relational.Type

Methods

showsPrec :: Int -> Delete p -> ShowS

show :: Delete p -> String

showList :: [Delete p] -> ShowS

newtype InsertQuery p

InsertQuery type.

Constructors

InsertQuery

Fields

• untypeInsertQuery :: String

Instances

UntypeableNoFetch InsertQuery

Defined in Database.Relational.Type

Methods

untypeNoFetch :: InsertQuery p -> String

Show (InsertQuery p)

Show insert SQL string.

Defined in Database.Relational.Type

Methods

showsPrec :: Int -> InsertQuery p -> ShowS

show :: InsertQuery p -> String

showList :: [InsertQuery p] -> ShowS

data Insert a

Insert type to insert record type a.

Constructors

Insert

Fields

• untypeInsert :: String
• chunkedInsert :: Maybe (String, Int)

Instances

UntypeableNoFetch Insert

Defined in Database.Relational.Type

Methods

untypeNoFetch :: Insert p -> String

Show (Insert a)

Show insert SQL string.

Defined in Database.Relational.Type

Methods

showsPrec :: Int -> Insert a -> ShowS

show :: Insert a -> String

showList :: [Insert a] -> ShowS

newtype Update p

Update type with place-holder parameter p.

Constructors

Update

Fields

• untypeUpdate :: String

Instances

UntypeableNoFetch Update

Defined in Database.Relational.Type

Methods

untypeNoFetch :: Update p -> String

Show (Update p)

Show update SQL string

Defined in Database.Relational.Type

Methods

showsPrec :: Int -> Update p -> ShowS

show :: Update p -> String

showList :: [Update p] -> ShowS

data KeyUpdate p a

Update type with key type p and update record type a. Columns to update are record columns other than key columns, So place-holder parameter type is the same as record type a.

Constructors

KeyUpdate

Fields

• updateKey :: Pi a p
• untypeKeyUpdate :: String

Instances

Show (KeyUpdate p a)

Show update SQL string

Defined in Database.Relational.Type

Methods

showsPrec :: Int -> KeyUpdate p a -> ShowS

show :: KeyUpdate p a -> String

showList :: [KeyUpdate p a] -> ShowS

newtype Query p a

Query type with place-holder parameter p and query result type a.

Constructors

Query

Fields

• untypeQuery :: String

Instances

Show (Query p a)

Show query SQL string

Defined in Database.Relational.Type

Methods

showsPrec :: Int -> Query p a -> ShowS

show :: Query p a -> String

showList :: [Query p a] -> ShowS

unsafeTypedQuery

Arguments

:: String

Query SQL to type

-> Query p a

Typed result

Unsafely make typed Query from SQL string.

relationalQuerySQL :: Config -> Relation p r -> QuerySuffix -> String

From Relation into untyped SQL query string.

relationalQuery_ :: Config -> Relation p r -> QuerySuffix -> Query p r

From Relation into typed Query with suffix SQL words.

relationalQuery' :: Relation p r -> QuerySuffix -> Query p r

From Relation into typed Query with suffix SQL words.

relationalQuery :: Relation p r -> Query p r

From Relation into typed Query.

typedKeyUpdate :: Table a -> Pi a p -> KeyUpdate p a

Make typed KeyUpdate from Table and key columns selector Pi.

typedKeyUpdateTable :: TableDerivable r => Relation () r -> Pi r p -> KeyUpdate p r

Make typed KeyUpdate object using derived info specified by Relation type.

keyUpdate :: TableDerivable r => Pi r p -> KeyUpdate p r

Make typed KeyUpdate from derived table and key columns selector Pi.

derivedKeyUpdate :: TableDerivable r => Pi r p -> KeyUpdate p r

Deprecated: use keyUpdate instead of this.

Make typed KeyUpdate from derived table and key columns selector Pi.

unsafeTypedUpdate :: String -> Update p

Unsafely make typed Update from SQL string.

updateSQL :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> String

Make untyped update SQL string from Table and Assign computation.

typedUpdate' :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

Make typed Update from Config, Table and Assign computation.

typedUpdate :: Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

Deprecated: use typedUpdate defaultConfig` instead of this.

Make typed Update using defaultConfig, Table and Assign computation.

update' :: TableDerivable r => Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

Make typed Update from Config, derived table and Assign computation.

derivedUpdate' :: TableDerivable r => Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

Deprecated: use update' instead of this.

Make typed Update from Config, derived table and Assign computation.

update :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

Make typed Update from defaultConfig, derived table and Assign computation.

updateNoPH :: TableDerivable r => (Record Flat r -> Assign r ()) -> Update ()

Make typed Update from defaultConfig, derived table and Assign computation with no(unit) placeholder.

derivedUpdate :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p

Deprecated: use update instead of this.

Make typed Update from defaultConfig, derived table and Assign computation.

typedUpdateAllColumn :: PersistableWidth r => Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)

Make typed Update from Table and Restrict computation. Update target is all column.

updateAllColumn' :: (PersistableWidth r, TableDerivable r) => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)

Make typed Update from Config, derived table and Restrict computation. Update target is all column.

derivedUpdateAllColumn' :: (PersistableWidth r, TableDerivable r) => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)

Deprecated: use updateAllColumn' instead of this.

Deprecated. use updateAllColumn'.

updateAllColumn :: (PersistableWidth r, TableDerivable r) => (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)

Make typed Update from defaultConfig, derived table and Restrict computation. Update target is all column.

updateAllColumnNoPH :: (PersistableWidth r, TableDerivable r) => (Record Flat r -> Restrict ()) -> Update r

Make typed Update from defaultConfig, derived table and Restrict computation without placeholder other than target table columns. Update target is all column.

derivedUpdateAllColumn :: (PersistableWidth r, TableDerivable r) => (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)

Deprecated: use updateAllColumn instead of this.

Deprecated. use updateAllColumn.

untypeChunkInsert :: Insert a -> String

Statement to use chunked insert

chunkSizeOfInsert :: Insert a -> Int

Size to use chunked insert

unsafeTypedInsert' :: String -> String -> Int -> Insert a

Unsafely make typed Insert from single insert and chunked insert SQL.

typedInsert' :: PersistableWidth r => Config -> Table r -> Pi r r' -> Insert r'

Make typed Insert from Table and columns selector Pi with configuration parameter.

typedInsert :: PersistableWidth r => Table r -> Pi r r' -> Insert r'

Deprecated: use typedInsert defaultConfig` instead of this.

Make typed Insert from Table and columns selector Pi.

insert :: (PersistableWidth r, TableDerivable r) => Pi r r' -> Insert r'

Table type inferred Insert.

derivedInsert :: (PersistableWidth r, TableDerivable r) => Pi r r' -> Insert r'

Deprecated: use insert instead of this.

Table type inferred Insert.

typedInsertValue' :: Config -> Table r -> InsertTarget p r -> Insert p

Make typed Insert from Config, Table and monadic builded InsertTarget object.

typedInsertValue :: Table r -> InsertTarget p r -> Insert p

Deprecated: use typedInsertValue defaultConfig` instead of this.

Make typed Insert from Table and monadic builded InsertTarget object.

insertValue' :: TableDerivable r => Config -> Register r (PlaceHolders p) -> Insert p

Make typed Insert from Config, derived table and monadic builded Register object.

derivedInsertValue' :: TableDerivable r => Config -> Register r (PlaceHolders p) -> Insert p

Deprecated: use insertValue' instead of this.

Make typed Insert from Config, derived table and monadic builded Register object.

insertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p

Make typed Insert from defaultConfig, derived table and monadic builded Register object.

insertValueNoPH :: TableDerivable r => Register r () -> Insert ()

Make typed Insert from defaultConfig, derived table and monadic builded Register object with no(unit) placeholder.

derivedInsertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p

Deprecated: use insertValue instead of this.

Make typed Insert from defaultConfig, derived table and monadic builded Register object.

insertValueList' :: (TableDerivable r, LiteralSQL r') => Config -> Pi r r' -> [r'] -> [Insert ()]

Make typed Insert list from Config and records list.

insertValueList :: (TableDerivable r, LiteralSQL r') => Pi r r' -> [r'] -> [Insert ()]

Make typed Insert list from records list.

insertQuerySQL :: Config -> Table r -> Pi r r' -> Relation p r' -> String

Make untyped insert select SQL string from Table, Pi and Relation.

typedInsertQuery' :: Config -> Table r -> Pi r r' -> Relation p r' -> InsertQuery p

Make typed InsertQuery from columns selector Table, Pi and Relation with configuration parameter.

typedInsertQuery :: Table r -> Pi r r' -> Relation p r' -> InsertQuery p

Deprecated: use typedInsertQuery defaultConfig` instead of this.

Make typed InsertQuery from columns selector Table, Pi and Relation.

insertQuery' :: TableDerivable r => Config -> Pi r r' -> Relation p r' -> InsertQuery p

Table type inferred InsertQuery.

insertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p

Table type inferred InsertQuery with defaultConfig.

derivedInsertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p

Deprecated: use insertQuery instead of this.

Table type inferred InsertQuery.

deleteSQL :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> String

Make untyped delete SQL string from Table and Restrict computation.

typedDelete' :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

Make typed Delete from Config, Table and Restrict computation.

typedDelete :: Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

Deprecated: use typedDelete defaultConfig` instead of this.

Make typed Delete from Table and Restrict computation.

delete' :: TableDerivable r => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

Make typed Delete from Config, derived table and Restrict computation.

derivedDelete' :: TableDerivable r => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

Deprecated: use delete' instead of this.

Make typed Delete from Config, derived table and Restrict computation.

delete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

Make typed Delete from defaultConfig, derived table and Restrict computation.

deleteNoPH :: TableDerivable r => (Record Flat r -> Restrict ()) -> Delete ()

Make typed Delete from defaultConfig, derived table and Restrict computation with no(unit) placeholder.

derivedDelete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p

Deprecated: use delete instead of this.

Make typed Delete from defaultConfig, derived table and Restrict computation.

data InsertTarget p r

InsertTarget type with place-holder parameter p and projected record type r.

type UpdateTarget p r = Record Flat r -> Assign r (PlaceHolders p)

UpdateTarget type with place-holder parameter p and projected record type r.

type Restriction p r = Record Flat r -> Restrict (PlaceHolders p)

Restriction type with place-holder parameter p and projected record type r.

restriction :: (Record Flat r -> Restrict ()) -> Restriction () r

Deprecated: same as ((>> return unitPH) .)

Deprecated.

restriction' :: (Record Flat r -> Restrict (PlaceHolders p)) -> Restriction p r

Deprecated: same as id

Deprecated.

sqlWhereFromRestriction :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> StringSQL

Deprecated: low-level API, this API will be expired.

SQL WHERE clause StringSQL string from Restrict computation.

updateTarget :: (Record Flat r -> Assign r ()) -> UpdateTarget () r

Deprecated: old-style API. Use new-style Database.Relational.updateNoPH.

Deprecated.

updateTarget' :: (Record Flat r -> Assign r (PlaceHolders p)) -> UpdateTarget p r

Deprecated: same as id

Deprecated.

liftTargetAllColumn :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders ())) -> Record Flat r -> Assign r (PlaceHolders r)

Deprecated: old-style API. use Database.Relational.updateAllColumnNoPH instead of this.

Lift Restrict computation to Assign computation. Assign target columns are all.

liftTargetAllColumn' :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders p)) -> Record Flat r -> Assign r (PlaceHolders (r, p))

Lift Restrict computation to Assign computation. Assign target columns are all. With placefolder type p.

updateTargetAllColumn :: PersistableWidth r => (Record Flat r -> Restrict ()) -> Record Flat r -> Assign r (PlaceHolders r)

Deprecated: Use Database.Relational.updateAllColumnNoPH instead of this.

Deprecated.

updateTargetAllColumn' :: PersistableWidth r => (Record Flat r -> Restrict (PlaceHolders p)) -> Record Flat r -> Assign r (PlaceHolders (r, p))

Deprecated: Use Database.Relational.updateAllColumn instead of this.

Deprecated.

sqlFromUpdateTarget :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> StringSQL

Deprecated: low-level API, this API will be expired.

SQL SET clause and WHERE clause StringSQL string from Assign computation.

insertTarget :: Register r () -> InsertTarget () r

Deprecated: old-style API. Use new-style Database.Relational.insertValueNoPH .

Finalize Register monad and generate InsertTarget.

insertTarget' :: Register r (PlaceHolders p) -> InsertTarget p r

Finalize Register monad and generate InsertTarget with place-holder parameter p.

piRegister :: PersistableWidth r => Pi r r' -> Register r (PlaceHolders r')

parametalized Register monad from Pi

sqlChunkFromInsertTarget :: Config -> Table r -> InsertTarget p r -> (StringSQL, Int)

Make StringSQL string of SQL INSERT record chunk statement from InsertTarget

sqlFromInsertTarget :: Config -> Table r -> InsertTarget p r -> StringSQL

Make StringSQL string of SQL INSERT statement from InsertTarget

sqlChunksFromRecordList :: LiteralSQL r' => Config -> Table r -> Pi r r' -> [r'] -> [StringSQL]

Make StringSQL strings of SQL INSERT strings from records list

module Database.Relational.Derives