Database.Beam.Query

Query type

data Q be (db :: (Type -> Type) -> Type) s a

The type of queries over the database db returning results of type a. The s argument is a threading argument meant to restrict cross-usage of QGenExprs. syntax represents the SQL syntax that this query is building.

Instances

Applicative (Q be db s)

Defined in Database.Beam.Query.Internal

Methods

pure :: a -> Q be db s a

(<*>) :: Q be db s (a -> b) -> Q be db s a -> Q be db s b

liftA2 :: (a -> b -> c) -> Q be db s a -> Q be db s b -> Q be db s c

(*>) :: Q be db s a -> Q be db s b -> Q be db s b

(<*) :: Q be db s a -> Q be db s b -> Q be db s a

Functor (Q be db s)

Defined in Database.Beam.Query.Internal

Methods

fmap :: (a -> b) -> Q be db s a -> Q be db s b

(<$) :: a -> Q be db s b -> Q be db s a

Monad (Q be db s)

Defined in Database.Beam.Query.Internal

Methods

(>>=) :: Q be db s a -> (a -> Q be db s b) -> Q be db s b

(>>) :: Q be db s a -> Q be db s b -> Q be db s b

return :: a -> Q be db s a

newtype QGenExpr context be s t

The type of lifted beam expressions that will yield the haskell type t.

context is a type-level representation of the types of expressions this can contain. For example, QAggregateContext represents expressions that may contain aggregates, and QWindowingContext represents expressions that may contain OVER.

syntax is the expression syntax being built (usually a type that implements IsSql92ExpressionSyntax at least, but not always).

s is a state threading parameter that prevents QGenExprs from incompatible sources to be combined. For example, this is used to prevent monadic joins from depending on the result of previous joins (so-called LATERAL joins).

Constructors

QExpr (TablePrefix -> BeamSqlBackendExpressionSyntax be)

Instances

(Beamable t, contextPredicate context) => ProjectibleWithPredicate contextPredicate be (WithExprContext (BeamSqlBackendExpressionSyntax' be)) (t (Nullable (QGenExpr context be s)))

Defined in Database.Beam.Query.Internal

Methods

project' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendExpressionSyntax' be)) -> (forall context0. contextPredicate context0 => Proxy context0 -> Proxy be -> WithExprContext (BeamSqlBackendExpressionSyntax' be) -> m (WithExprContext (BeamSqlBackendExpressionSyntax' be))) -> t (Nullable (QGenExpr context be s)) -> m (t (Nullable (QGenExpr context be s)))

projectSkeleton' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendExpressionSyntax' be)) -> (forall context0. contextPredicate context0 => Proxy context0 -> Proxy be -> m (WithExprContext (BeamSqlBackendExpressionSyntax' be))) -> m (t (Nullable (QGenExpr context be s)))

(Beamable t, contextPredicate context) => ProjectibleWithPredicate contextPredicate be (WithExprContext (BeamSqlBackendExpressionSyntax' be)) (t (QGenExpr context be s))

Defined in Database.Beam.Query.Internal

Methods

project' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendExpressionSyntax' be)) -> (forall context0. contextPredicate context0 => Proxy context0 -> Proxy be -> WithExprContext (BeamSqlBackendExpressionSyntax' be) -> m (WithExprContext (BeamSqlBackendExpressionSyntax' be))) -> t (QGenExpr context be s) -> m (t (QGenExpr context be s))

projectSkeleton' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendExpressionSyntax' be)) -> (forall context0. contextPredicate context0 => Proxy context0 -> Proxy be -> m (WithExprContext (BeamSqlBackendExpressionSyntax' be))) -> m (t (QGenExpr context be s))

contextPredicate context => ProjectibleWithPredicate contextPredicate be (WithExprContext (BeamSqlBackendExpressionSyntax' be)) (QGenExpr context be s a)

Defined in Database.Beam.Query.Internal

Methods

project' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendExpressionSyntax' be)) -> (forall context0. contextPredicate context0 => Proxy context0 -> Proxy be -> WithExprContext (BeamSqlBackendExpressionSyntax' be) -> m (WithExprContext (BeamSqlBackendExpressionSyntax' be))) -> QGenExpr context be s a -> m (QGenExpr context be s a)

projectSkeleton' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendExpressionSyntax' be)) -> (forall context0. contextPredicate context0 => Proxy context0 -> Proxy be -> m (WithExprContext (BeamSqlBackendExpressionSyntax' be))) -> m (QGenExpr context be s a)

Beamable tbl => ThreadRewritable s (tbl (Nullable (QGenExpr ctxt syntax s)))

Defined in Database.Beam.Query.Internal

Associated Types

type WithRewrittenThread s s' (tbl (Nullable (QGenExpr ctxt syntax s)))

Methods

rewriteThread :: Proxy s' -> tbl (Nullable (QGenExpr ctxt syntax s)) -> WithRewrittenThread s s' (tbl (Nullable (QGenExpr ctxt syntax s)))

Beamable tbl => ThreadRewritable s (tbl (QGenExpr ctxt syntax s))

Defined in Database.Beam.Query.Internal

Associated Types

type WithRewrittenThread s s' (tbl (QGenExpr ctxt syntax s))

Methods

rewriteThread :: Proxy s' -> tbl (QGenExpr ctxt syntax s) -> WithRewrittenThread s s' (tbl (QGenExpr ctxt syntax s))

(BeamSqlBackend be, Beamable t) => SqlDeconstructMaybe be (t (Nullable (QGenExpr ctxt be s))) (t (QGenExpr ctxt be s)) s

Defined in Database.Beam.Query.Combinators

Methods

isJust_ :: t (Nullable (QGenExpr ctxt be s)) -> QGenExpr ctxt0 be s Bool

isNothing_ :: t (Nullable (QGenExpr ctxt be s)) -> QGenExpr ctxt0 be s Bool

maybe_ :: QGenExpr ctxt0 be s y -> (t (QGenExpr ctxt be s) -> QGenExpr ctxt0 be s y) -> t (Nullable (QGenExpr ctxt be s)) -> QGenExpr ctxt0 be s y

(TypeError ('Text "Missing mandatory sorting order. Use either 'asc_' or 'desc_' to specify sorting order.") :: Constraint) => SqlOrderable be (QGenExpr ctx be s a)

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: Proxy be -> QGenExpr ctx be s a -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]

ThreadRewritable s (QGenExpr ctxt syntax s a)

Defined in Database.Beam.Query.Internal

Associated Types

type WithRewrittenThread s s' (QGenExpr ctxt syntax s a)

Methods

rewriteThread :: Proxy s' -> QGenExpr ctxt syntax s a -> WithRewrittenThread s s' (QGenExpr ctxt syntax s a)

BeamSqlBackend be => SqlDeconstructMaybe be (QGenExpr ctxt be s (Maybe x)) (QGenExpr ctxt be s x) s

Defined in Database.Beam.Query.Combinators

Methods

isJust_ :: QGenExpr ctxt be s (Maybe x) -> QGenExpr ctxt0 be s Bool

isNothing_ :: QGenExpr ctxt be s (Maybe x) -> QGenExpr ctxt0 be s Bool

maybe_ :: QGenExpr ctxt0 be s y -> (QGenExpr ctxt be s x -> QGenExpr ctxt0 be s y) -> QGenExpr ctxt be s (Maybe x) -> QGenExpr ctxt0 be s y

(Beamable table, BeamSqlBackend be, FieldsFulfillConstraintNullable (BeamSqlBackendCanSerialize be) table) => SqlValable (table (Nullable (QGenExpr ctxt be s)))

Defined in Database.Beam.Query.Combinators

Methods

val_ :: HaskellLiteralForQExpr (table (Nullable (QGenExpr ctxt be s))) -> table (Nullable (QGenExpr ctxt be s))

(Beamable table, BeamSqlBackend be, FieldsFulfillConstraint (BeamSqlBackendCanSerialize be) table) => SqlValable (table (QGenExpr ctxt be s))

Defined in Database.Beam.Query.Combinators

Methods

val_ :: HaskellLiteralForQExpr (table (QGenExpr ctxt be s)) -> table (QGenExpr ctxt be s)

Beamable tbl => ContextRewritable (tbl (Nullable (QGenExpr old syntax s)))

Defined in Database.Beam.Query.Internal

Associated Types

type WithRewrittenContext (tbl (Nullable (QGenExpr old syntax s))) ctxt

Methods

rewriteContext :: Proxy ctxt -> tbl (Nullable (QGenExpr old syntax s)) -> WithRewrittenContext (tbl (Nullable (QGenExpr old syntax s))) ctxt

Beamable tbl => ContextRewritable (tbl (QGenExpr old syntax s))

Defined in Database.Beam.Query.Internal

Associated Types

type WithRewrittenContext (tbl (QGenExpr old syntax s)) ctxt

Methods

rewriteContext :: Proxy ctxt -> tbl (QGenExpr old syntax s) -> WithRewrittenContext (tbl (QGenExpr old syntax s)) ctxt

Beamable tbl => QGroupable (tbl (Nullable (QExpr be s))) (tbl (Nullable (QGroupExpr be s)))

group_ for any Beamable type. Adds every field in the type to the grouping key. This is the equivalent of including the grouping expression of each field in the type as part of the aggregate projection

Defined in Database.Beam.Query.Aggregate

Methods

group_ :: tbl (Nullable (QExpr be s)) -> tbl (Nullable (QGroupExpr be s))

Beamable tbl => QGroupable (tbl (QExpr be s)) (tbl (QGroupExpr be s))

group_ for any Beamable type. Adds every field in the type to the grouping key. This is the equivalent of including the grouping expression of each field in the type as part of the aggregate projection

Defined in Database.Beam.Query.Aggregate

Methods

group_ :: tbl (QExpr be s) -> tbl (QGroupExpr be s)

(Table t, BeamSqlBackend be) => SqlJustable (t (QExpr be s)) (t (Nullable (QExpr be s)))

Defined in Database.Beam.Query.Combinators

Methods

just_ :: t (QExpr be s) -> t (Nullable (QExpr be s))

nothing_ :: t (Nullable (QExpr be s))

(Table t, BeamSqlBackend be) => SqlJustable (PrimaryKey t (QExpr be s)) (PrimaryKey t (Nullable (QExpr be s)))

Defined in Database.Beam.Query.Combinators

Methods

just_ :: PrimaryKey t (QExpr be s) -> PrimaryKey t (Nullable (QExpr be s))

nothing_ :: PrimaryKey t (Nullable (QExpr be s))

(BeamSqlBackend be, Beamable tbl, FieldsFulfillConstraintNullable (HasSqlEqualityCheck be) tbl) => SqlEq (QGenExpr context be s) (tbl (Nullable (QGenExpr context be s)))

Defined in Database.Beam.Query.Ord

Methods

(==.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s Bool

(/=.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s Bool

(==?.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s SqlBool

(/=?.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s SqlBool

(BeamSqlBackend be, Beamable tbl, FieldsFulfillConstraint (HasSqlEqualityCheck be) tbl) => SqlEq (QGenExpr context be s) (tbl (QGenExpr context be s))

Compare two arbitrary Beamable types containing QGenExprs for equality.

Defined in Database.Beam.Query.Ord

Methods

(==.) :: tbl (QGenExpr context be s) -> tbl (QGenExpr context be s) -> QGenExpr context be s Bool

(/=.) :: tbl (QGenExpr context be s) -> tbl (QGenExpr context be s) -> QGenExpr context be s Bool

(==?.) :: tbl (QGenExpr context be s) -> tbl (QGenExpr context be s) -> QGenExpr context be s SqlBool

(/=?.) :: tbl (QGenExpr context be s) -> tbl (QGenExpr context be s) -> QGenExpr context be s SqlBool

(HasSqlInTable be, Beamable table) => SqlIn (QGenExpr context be s) (table (QGenExpr context be s))

Defined in Database.Beam.Query.Ord

Methods

in_ :: table (QGenExpr context be s) -> [table (QGenExpr context be s)] -> QGenExpr context be s Bool

QGroupable (QExpr be s a) (QGroupExpr be s a)

group_ for simple value expressions.

Defined in Database.Beam.Query.Aggregate

Methods

group_ :: QExpr be s a -> QGroupExpr be s a

BeamSqlBackend be => SqlJustable (QExpr be s a) (QExpr be s (Maybe a))

Defined in Database.Beam.Query.Combinators

Methods

just_ :: QExpr be s a -> QExpr be s (Maybe a)

nothing_ :: QExpr be s (Maybe a)

(BeamSqlBackend be, HasSqlQuantifiedEqualityCheck be a) => SqlEqQuantified (QGenExpr context be s) (QQuantified be s a) (QGenExpr context be s a)

Two arbitrary expressions can be quantifiably compared for equality.

Defined in Database.Beam.Query.Ord

Methods

(==*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s SqlBool

(/=*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s SqlBool

BeamSqlBackend be => SqlOrdQuantified (QGenExpr context be s) (QQuantified be s a) (QGenExpr context be s a)

Defined in Database.Beam.Query.Ord

Methods

(<*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool

(>*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool

(<=*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool

(>=*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool

(BeamSqlBackend be, HasSqlEqualityCheck be a) => SqlEq (QGenExpr context be s) (QGenExpr context be s a)

Compare two arbitrary expressions (of the same type) for equality

Defined in Database.Beam.Query.Ord

Methods

(==.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool

(/=.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool

(==?.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s SqlBool

(/=?.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s SqlBool

BeamSqlBackend be => SqlIn (QGenExpr context be s) (QGenExpr context be s a)

Defined in Database.Beam.Query.Ord

Methods

in_ :: QGenExpr context be s a -> [QGenExpr context be s a] -> QGenExpr context be s Bool

BeamSqlBackend be => SqlOrd (QGenExpr context be s) (QGenExpr context be s a)

Defined in Database.Beam.Query.Ord

Methods

(<.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool

(>.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool

(<=.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool

(>=.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool

Retaggable (QGenExpr ctxt expr s) (QGenExpr ctxt expr s t)

Defined in Database.Beam.Query.Internal

Associated Types

type Retag tag (QGenExpr ctxt expr s t)

Methods

retag :: forall (tag :: (Type -> Type) -> Type -> Type). (forall a. Columnar' (QGenExpr ctxt expr s) a -> Columnar' (tag (QGenExpr ctxt expr s)) a) -> QGenExpr ctxt expr s t -> Retag tag (QGenExpr ctxt expr s t)

(BeamSqlBackend backend, BeamSqlBackendCanSerialize backend [Char]) => IsString (QGenExpr context backend s Text)

Defined in Database.Beam.Query.Internal

Methods

fromString :: String -> QGenExpr context backend s Text

(Num a, BeamSqlBackend be, BeamSqlBackendCanSerialize be a) => Num (QGenExpr context be s a)

Defined in Database.Beam.Query.Internal

Methods

(+) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a

(-) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a

(*) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a

negate :: QGenExpr context be s a -> QGenExpr context be s a

abs :: QGenExpr context be s a -> QGenExpr context be s a

signum :: QGenExpr context be s a -> QGenExpr context be s a

fromInteger :: Integer -> QGenExpr context be s a

(Fractional a, BeamSqlBackend be, BeamSqlBackendCanSerialize be a) => Fractional (QGenExpr context be s a)

Defined in Database.Beam.Query.Internal

Methods

(/) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a

recip :: QGenExpr context be s a -> QGenExpr context be s a

fromRational :: Rational -> QGenExpr context be s a

(BeamSqlBackendCanSerialize be a, BeamSqlBackend be) => SqlValable (QGenExpr ctxt be s a)

Defined in Database.Beam.Query.Combinators

Methods

val_ :: HaskellLiteralForQExpr (QGenExpr ctxt be s a) -> QGenExpr ctxt be s a

ContextRewritable (QGenExpr old syntax s a)

Defined in Database.Beam.Query.Internal

Associated Types

type WithRewrittenContext (QGenExpr old syntax s a) ctxt

Methods

rewriteContext :: Proxy ctxt -> QGenExpr old syntax s a -> WithRewrittenContext (QGenExpr old syntax s a) ctxt

BeamSqlBackend be => Eq (QGenExpr context be s t)

Defined in Database.Beam.Query.Internal

Methods

(==) :: QGenExpr context be s t -> QGenExpr context be s t -> Bool

(/=) :: QGenExpr context be s t -> QGenExpr context be s t -> Bool

type WithRewrittenThread s s' (tbl (Nullable (QGenExpr ctxt syntax s)))

Defined in Database.Beam.Query.Internal

type WithRewrittenThread s s' (tbl (Nullable (QGenExpr ctxt syntax s))) = tbl (Nullable (QGenExpr ctxt syntax s'))

type WithRewrittenThread s s' (tbl (QGenExpr ctxt syntax s))

Defined in Database.Beam.Query.Internal

type WithRewrittenThread s s' (tbl (QGenExpr ctxt syntax s)) = tbl (QGenExpr ctxt syntax s')

type WithRewrittenThread s s' (QGenExpr ctxt syntax s a)

Defined in Database.Beam.Query.Internal

type WithRewrittenThread s s' (QGenExpr ctxt syntax s a) = QGenExpr ctxt syntax s' a

type Retag tag (QGenExpr ctxt expr s t)

Defined in Database.Beam.Query.Internal

type Retag tag (QGenExpr ctxt expr s t) = Columnar (tag (QGenExpr ctxt expr s)) t

type HaskellLiteralForQExpr (table (QGenExpr context be s))

Defined in Database.Beam.Query.Combinators

type HaskellLiteralForQExpr (table (QGenExpr context be s)) = table Identity

type QExprToField (table (Nullable (QGenExpr context syntax s)))

Defined in Database.Beam.Query.Types

type QExprToField (table (Nullable (QGenExpr context syntax s))) = table (Nullable (QField s))

type QExprToField (table (QGenExpr context syntax s))

Defined in Database.Beam.Query.Types

type QExprToField (table (QGenExpr context syntax s)) = table (QField s)

type QExprToIdentity (table (QGenExpr context syntax s))

Defined in Database.Beam.Query.Types

type QExprToIdentity (table (QGenExpr context syntax s)) = table Identity

type WithRewrittenContext (tbl (Nullable (QGenExpr old syntax s))) ctxt

Defined in Database.Beam.Query.Internal

type WithRewrittenContext (tbl (Nullable (QGenExpr old syntax s))) ctxt = tbl (Nullable (QGenExpr ctxt syntax s))

type WithRewrittenContext (tbl (QGenExpr old syntax s)) ctxt

Defined in Database.Beam.Query.Internal

type WithRewrittenContext (tbl (QGenExpr old syntax s)) ctxt = tbl (QGenExpr ctxt syntax s)

type HaskellLiteralForQExpr (QGenExpr context be s a)

Defined in Database.Beam.Query.Combinators

type HaskellLiteralForQExpr (QGenExpr context be s a) = a

type QExprToField (QGenExpr ctxt syntax s a)

Defined in Database.Beam.Query.Types

type QExprToField (QGenExpr ctxt syntax s a) = QField s a

type QExprToIdentity (QGenExpr context syntax s a)

Defined in Database.Beam.Query.Types

type QExprToIdentity (QGenExpr context syntax s a) = a

type WithRewrittenContext (QGenExpr old syntax s a) ctxt

Defined in Database.Beam.Query.Internal

type WithRewrittenContext (QGenExpr old syntax s a) ctxt = QGenExpr ctxt syntax s a

type QExpr = QGenExpr QValueContext

QGenExprs represent expressions not containing aggregates.

type family QExprToIdentity x

Instances

type QExprToIdentity ()

Defined in Database.Beam.Query.Types

type QExprToIdentity () = ()

type QExprToIdentity (table (Nullable c))

Defined in Database.Beam.Query.Types

type QExprToIdentity (table (Nullable c)) = Maybe (QExprToIdentity (table c))

type QExprToIdentity (table (QGenExpr context syntax s))

Defined in Database.Beam.Query.Types

type QExprToIdentity (table (QGenExpr context syntax s)) = table Identity

type QExprToIdentity (Vector n a)

Defined in Database.Beam.Query.Types

type QExprToIdentity (Vector n a) = Vector n (QExprToIdentity a)

type QExprToIdentity (a, b)

Defined in Database.Beam.Query.Types

type QExprToIdentity (a, b) = (QExprToIdentity a, QExprToIdentity b)

type QExprToIdentity (a, b, c)

Defined in Database.Beam.Query.Types

type QExprToIdentity (a, b, c) = (QExprToIdentity a, QExprToIdentity b, QExprToIdentity c)

type QExprToIdentity (QGenExpr context syntax s a)

Defined in Database.Beam.Query.Types

type QExprToIdentity (QGenExpr context syntax s a) = a

type QExprToIdentity (a, b, c, d)

Defined in Database.Beam.Query.Types

type QExprToIdentity (a, b, c, d) = (QExprToIdentity a, QExprToIdentity b, QExprToIdentity c, QExprToIdentity d)

type QExprToIdentity (a, b, c, d, e)

Defined in Database.Beam.Query.Types

type QExprToIdentity (a, b, c, d, e) = (QExprToIdentity a, QExprToIdentity b, QExprToIdentity c, QExprToIdentity d, QExprToIdentity e)

type QExprToIdentity (a, b, c, d, e, f)

Defined in Database.Beam.Query.Types

type QExprToIdentity (a, b, c, d, e, f) = (QExprToIdentity a, QExprToIdentity b, QExprToIdentity c, QExprToIdentity d, QExprToIdentity e, QExprToIdentity f)

type QExprToIdentity (a, b, c, d, e, f, g)

Defined in Database.Beam.Query.Types

type QExprToIdentity (a, b, c, d, e, f, g) = (QExprToIdentity a, QExprToIdentity b, QExprToIdentity c, QExprToIdentity d, QExprToIdentity e, QExprToIdentity f, QExprToIdentity g)

type QExprToIdentity (a, b, c, d, e, f, g, h)

Defined in Database.Beam.Query.Types

type QExprToIdentity (a, b, c, d, e, f, g, h) = (QExprToIdentity a, QExprToIdentity b, QExprToIdentity c, QExprToIdentity d, QExprToIdentity e, QExprToIdentity f, QExprToIdentity g, QExprToIdentity h)

type family QExprToField x

Instances

type QExprToField ()

Defined in Database.Beam.Query.Types

type QExprToField () = ()

type QExprToField (table (Nullable (QGenExpr context syntax s)))

Defined in Database.Beam.Query.Types

type QExprToField (table (Nullable (QGenExpr context syntax s))) = table (Nullable (QField s))

type QExprToField (table (QGenExpr context syntax s))

Defined in Database.Beam.Query.Types

type QExprToField (table (QGenExpr context syntax s)) = table (QField s)

type QExprToField (Vector n a)

Defined in Database.Beam.Query.Types

type QExprToField (Vector n a) = Vector n (QExprToField a)

type QExprToField (a, b)

Defined in Database.Beam.Query.Types

type QExprToField (a, b) = (QExprToField a, QExprToField b)

type QExprToField (a, b, c)

Defined in Database.Beam.Query.Types

type QExprToField (a, b, c) = (QExprToField a, QExprToField b, QExprToField c)

type QExprToField (QGenExpr ctxt syntax s a)

Defined in Database.Beam.Query.Types

type QExprToField (QGenExpr ctxt syntax s a) = QField s a

type QExprToField (a, b, c, d)

Defined in Database.Beam.Query.Types

type QExprToField (a, b, c, d) = (QExprToField a, QExprToField b, QExprToField c, QExprToField d)

type QExprToField (a, b, c, d, e)

Defined in Database.Beam.Query.Types

type QExprToField (a, b, c, d, e) = (QExprToField a, QExprToField b, QExprToField c, QExprToField d, QExprToField e)

type QExprToField (a, b, c, d, e, f)

Defined in Database.Beam.Query.Types

type QExprToField (a, b, c, d, e, f) = (QExprToField a, QExprToField b, QExprToField c, QExprToField d, QExprToField e, QExprToField f)

type QExprToField (a, b, c, d, e, f, g)

Defined in Database.Beam.Query.Types

type QExprToField (a, b, c, d, e, f, g) = (QExprToField a, QExprToField b, QExprToField c, QExprToField d, QExprToField e, QExprToField f, QExprToField g)

type QExprToField (a, b, c, d, e, f, g, h)

Defined in Database.Beam.Query.Types

type QExprToField (a, b, c, d, e, f, g, h) = (QExprToField a, QExprToField b, QExprToField c, QExprToField d, QExprToField e, QExprToField f, QExprToField g, QExprToField h)

data QWindow be s

Instances

contextPredicate QWindowFrameContext => ProjectibleWithPredicate contextPredicate be (WithExprContext (BeamSqlBackendWindowFrameSyntax' be)) (QWindow be s)

Defined in Database.Beam.Query.Internal

Methods

project' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendWindowFrameSyntax' be)) -> (forall context. contextPredicate context => Proxy context -> Proxy be -> WithExprContext (BeamSqlBackendWindowFrameSyntax' be) -> m (WithExprContext (BeamSqlBackendWindowFrameSyntax' be))) -> QWindow be s -> m (QWindow be s)

projectSkeleton' :: Monad m => Proxy contextPredicate -> Proxy (be, WithExprContext (BeamSqlBackendWindowFrameSyntax' be)) -> (forall context. contextPredicate context => Proxy context -> Proxy be -> m (WithExprContext (BeamSqlBackendWindowFrameSyntax' be))) -> m (QWindow be s)

type Projectible be = ProjectibleWithPredicate AnyType be (WithExprContext (BeamSqlBackendExpressionSyntax' be))

class BeamSqlBackend be => HasQBuilder be where

Methods

buildSqlQuery :: Projectible be a => TablePrefix -> Q be db s a -> BeamSqlBackendSelectSyntax be

Instances

BeamSqlBackend (MockSqlBackend cmd) => HasQBuilder (MockSqlBackend cmd)

Defined in Database.Beam.Query.Types

Methods

buildSqlQuery :: forall a (db :: (Type -> Type) -> Type) s. Projectible (MockSqlBackend cmd) a => TablePrefix -> Q (MockSqlBackend cmd) db s a -> BeamSqlBackendSelectSyntax (MockSqlBackend cmd)

Query expression contexts

A context is a type-level value that signifies where an expression can be used. For example, QGenExpr corresponds to QGenExprs that result in values. In reality, QGenExpr is really QGenExpr parameterized over the QValueContext. Similarly, QAgg represents expressions that contain aggregates, but it is just QGenExpr parameterized over QAggregateContext

data QAggregateContext

Instances

type ContextName QAggregateContext

Defined in Database.Beam.Query.Internal

type ContextName QAggregateContext = "an aggregate"

data QGroupingContext

Instances

Beamable tbl => QGroupable (tbl (Nullable (QExpr be s))) (tbl (Nullable (QGroupExpr be s)))

group_ for any Beamable type. Adds every field in the type to the grouping key. This is the equivalent of including the grouping expression of each field in the type as part of the aggregate projection

Defined in Database.Beam.Query.Aggregate

Methods

group_ :: tbl (Nullable (QExpr be s)) -> tbl (Nullable (QGroupExpr be s))

Beamable tbl => QGroupable (tbl (QExpr be s)) (tbl (QGroupExpr be s))

group_ for any Beamable type. Adds every field in the type to the grouping key. This is the equivalent of including the grouping expression of each field in the type as part of the aggregate projection

Defined in Database.Beam.Query.Aggregate

Methods

group_ :: tbl (QExpr be s) -> tbl (QGroupExpr be s)

QGroupable (QExpr be s a) (QGroupExpr be s a)

group_ for simple value expressions.

Defined in Database.Beam.Query.Aggregate

Methods

group_ :: QExpr be s a -> QGroupExpr be s a

type ContextName QGroupingContext

Defined in Database.Beam.Query.Internal

type ContextName QGroupingContext = "an aggregate grouping"

data QValueContext

Instances

Beamable tbl => QGroupable (tbl (Nullable (QExpr be s))) (tbl (Nullable (QGroupExpr be s)))

group_ for any Beamable type. Adds every field in the type to the grouping key. This is the equivalent of including the grouping expression of each field in the type as part of the aggregate projection

Defined in Database.Beam.Query.Aggregate

Methods

group_ :: tbl (Nullable (QExpr be s)) -> tbl (Nullable (QGroupExpr be s))

Beamable tbl => QGroupable (tbl (QExpr be s)) (tbl (QGroupExpr be s))

group_ for any Beamable type. Adds every field in the type to the grouping key. This is the equivalent of including the grouping expression of each field in the type as part of the aggregate projection

Defined in Database.Beam.Query.Aggregate

Methods

group_ :: tbl (QExpr be s) -> tbl (QGroupExpr be s)

(Table t, BeamSqlBackend be) => SqlJustable (t (QExpr be s)) (t (Nullable (QExpr be s)))

Defined in Database.Beam.Query.Combinators

Methods

just_ :: t (QExpr be s) -> t (Nullable (QExpr be s))

nothing_ :: t (Nullable (QExpr be s))

(Table t, BeamSqlBackend be) => SqlJustable (PrimaryKey t (QExpr be s)) (PrimaryKey t (Nullable (QExpr be s)))

Defined in Database.Beam.Query.Combinators

Methods

just_ :: PrimaryKey t (QExpr be s) -> PrimaryKey t (Nullable (QExpr be s))

nothing_ :: PrimaryKey t (Nullable (QExpr be s))

QGroupable (QExpr be s a) (QGroupExpr be s a)

group_ for simple value expressions.

Defined in Database.Beam.Query.Aggregate

Methods

group_ :: QExpr be s a -> QGroupExpr be s a

BeamSqlBackend be => SqlJustable (QExpr be s a) (QExpr be s (Maybe a))

Defined in Database.Beam.Query.Combinators

Methods

just_ :: QExpr be s a -> QExpr be s (Maybe a)

nothing_ :: QExpr be s (Maybe a)

type ContextName QValueContext

Defined in Database.Beam.Query.Internal

type ContextName QValueContext = "a value"

data QWindowingContext

Instances

type ContextName QWindowingContext

Defined in Database.Beam.Query.Internal

type ContextName QWindowingContext = "a window expression"

data QWindowFrameContext

Instances

type ContextName QWindowFrameContext

Defined in Database.Beam.Query.Internal

type ContextName QWindowFrameContext = "a window frame"

type QGenExprTable ctxt be s tbl = tbl (QGenExpr ctxt be s)

A version of the table where each field is a QGenExpr

type QExprTable be s tbl = QGenExprTable QValueContext be s tbl

data QAssignment be s

Instances

Monoid (QAssignment be s)

Defined in Database.Beam.Query.Internal

Methods

mempty :: QAssignment be s

mappend :: QAssignment be s -> QAssignment be s -> QAssignment be s

mconcat :: [QAssignment be s] -> QAssignment be s

Semigroup (QAssignment be s)

Defined in Database.Beam.Query.Internal

Methods

(<>) :: QAssignment be s -> QAssignment be s -> QAssignment be s

sconcat :: NonEmpty (QAssignment be s) -> QAssignment be s

stimes :: Integral b => b -> QAssignment be s -> QAssignment be s

data QField s ty

Instances

Beamable t => ProjectibleWithPredicate AnyType () Text (t (Nullable (QField s)))

Defined in Database.Beam.Query.Internal

Methods

project' :: Monad m => Proxy AnyType -> Proxy ((), Text) -> (forall context. AnyType context => Proxy context -> Proxy () -> Text -> m Text) -> t (Nullable (QField s)) -> m (t (Nullable (QField s)))

projectSkeleton' :: Monad m => Proxy AnyType -> Proxy ((), Text) -> (forall context. AnyType context => Proxy context -> Proxy () -> m Text) -> m (t (Nullable (QField s)))

Beamable t => ProjectibleWithPredicate AnyType () Text (t (QField s))

Defined in Database.Beam.Query.Internal

Methods

project' :: Monad m => Proxy AnyType -> Proxy ((), Text) -> (forall context. AnyType context => Proxy context -> Proxy () -> Text -> m Text) -> t (QField s) -> m (t (QField s))

projectSkeleton' :: Monad m => Proxy AnyType -> Proxy ((), Text) -> (forall context. AnyType context => Proxy context -> Proxy () -> m Text) -> m (t (QField s))

ProjectibleWithPredicate AnyType () Text (QField s a)

Defined in Database.Beam.Query.Internal

Methods

project' :: Monad m => Proxy AnyType -> Proxy ((), Text) -> (forall context. AnyType context => Proxy context -> Proxy () -> Text -> m Text) -> QField s a -> m (QField s a)

projectSkeleton' :: Monad m => Proxy AnyType -> Proxy ((), Text) -> (forall context. AnyType context => Proxy context -> Proxy () -> m Text) -> m (QField s a)

Show (QField s ty)

Defined in Database.Beam.Query.Internal

Methods

showsPrec :: Int -> QField s ty -> ShowS

show :: QField s ty -> String

showList :: [QField s ty] -> ShowS

Eq (QField s ty)

Defined in Database.Beam.Query.Internal

Methods

(==) :: QField s ty -> QField s ty -> Bool

(/=) :: QField s ty -> QField s ty -> Bool

Ord (QField s ty)

Defined in Database.Beam.Query.Internal

Methods

compare :: QField s ty -> QField s ty -> Ordering

(<) :: QField s ty -> QField s ty -> Bool

(<=) :: QField s ty -> QField s ty -> Bool

(>) :: QField s ty -> QField s ty -> Bool

(>=) :: QField s ty -> QField s ty -> Bool

max :: QField s ty -> QField s ty -> QField s ty

min :: QField s ty -> QField s ty -> QField s ty

data QFieldAssignment be tbl a

data QBaseScope

Various SQL functions and constructs

coalesce_ :: BeamSqlBackend be => [QGenExpr ctxt be s (Maybe a)] -> QGenExpr ctxt be s a -> QGenExpr ctxt be s a

SQL COALESCE support

fromMaybe_ :: BeamSqlBackend be => QGenExpr ctxt be s a -> QGenExpr ctxt be s (Maybe a) -> QGenExpr ctxt be s a

Convert a Maybe value to a concrete value, by suppling a default

position_ :: (BeamSqlBackendIsString be text, BeamSqlBackend be, Integral b) => QExpr be s text -> QExpr be s text -> QExpr be s b

SQL POSITION(.. IN ..) function

charLength_ :: (BeamSqlBackend be, BeamSqlBackendIsString be text, Integral a) => QGenExpr context be s text -> QGenExpr context be s a

SQL CHAR_LENGTH function

octetLength_ :: (BeamSqlBackend be, BeamSqlBackendIsString be text, Integral a) => QGenExpr context be s text -> QGenExpr context be s a

SQL OCTET_LENGTH function

bitLength_ :: (BeamSqlBackend be, Integral a) => QGenExpr context be s SqlBitString -> QGenExpr context be s a

SQL BIT_LENGTH function

currentTimestamp_ :: BeamSqlBackend be => QGenExpr ctxt be s LocalTime

SQL CURRENT_TIMESTAMP function

lower_ :: (BeamSqlBackendIsString be text, BeamSqlBackend be) => QGenExpr context be s text -> QGenExpr context be s text

SQL LOWER function

upper_ :: (BeamSqlBackendIsString be text, BeamSqlBackend be) => QGenExpr context be s text -> QGenExpr context be s text

SQL UPPER function

trim_ :: (BeamSqlBackendIsString be text, BeamSqlBackend be) => QGenExpr context be s text -> QGenExpr context be s text

SQL TRIM function

IF-THEN-ELSE support

if_ :: BeamSqlBackend be => [QIfCond context be s a] -> QIfElse context be s a -> QGenExpr context be s a

then_ :: QGenExpr context be s Bool -> QGenExpr context be s a -> QIfCond context be s a

else_ :: QGenExpr context be s a -> QIfElse context be s a

then_' :: QGenExpr context be s SqlBool -> QGenExpr context be s a -> QIfCond context be s a

ifThenElse_ :: BeamSqlBackend be => QGenExpr context be s Bool -> QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a

bool_ :: BeamSqlBackend be => QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool -> QGenExpr context be s a

SQL UPDATE assignments

(<-.) :: SqlUpdatable be s lhs rhs => lhs -> rhs -> QAssignment be s infix 4

Update a QField or Beamable type containing QFields with the given QGenExpr or Beamable type containing QGenExpr

current_ :: BeamSqlBackend be => QField s ty -> QExpr be s ty

Extract an expression representing the current (non-UPDATEd) value of a QField

Project Haskell values to QGenExprs

type family HaskellLiteralForQExpr x = a

Instances

type HaskellLiteralForQExpr (table (Nullable f))

Defined in Database.Beam.Query.Combinators

type HaskellLiteralForQExpr (table (Nullable f))

type HaskellLiteralForQExpr (table (QGenExpr context be s))

Defined in Database.Beam.Query.Combinators

type HaskellLiteralForQExpr (table (QGenExpr context be s)) = table Identity

type HaskellLiteralForQExpr (QGenExpr context be s a)

Defined in Database.Beam.Query.Combinators

type HaskellLiteralForQExpr (QGenExpr context be s a) = a

class SqlValable a where

Methods

val_ :: HaskellLiteralForQExpr a -> a

Instances

(Beamable table, BeamSqlBackend be, FieldsFulfillConstraintNullable (BeamSqlBackendCanSerialize be) table) => SqlValable (table (Nullable (QGenExpr ctxt be s)))

Defined in Database.Beam.Query.Combinators

Methods

val_ :: HaskellLiteralForQExpr (table (Nullable (QGenExpr ctxt be s))) -> table (Nullable (QGenExpr ctxt be s))

(Beamable table, BeamSqlBackend be, FieldsFulfillConstraint (BeamSqlBackendCanSerialize be) table) => SqlValable (table (QGenExpr ctxt be s))

Defined in Database.Beam.Query.Combinators

Methods

val_ :: HaskellLiteralForQExpr (table (QGenExpr ctxt be s)) -> table (QGenExpr ctxt be s)

(BeamSqlBackendCanSerialize be a, BeamSqlBackend be) => SqlValable (QGenExpr ctxt be s a)

Defined in Database.Beam.Query.Combinators

Methods

val_ :: HaskellLiteralForQExpr (QGenExpr ctxt be s a) -> QGenExpr ctxt be s a

type SqlValableTable be table = (Beamable table, FieldsFulfillConstraint (HasSqlValueSyntax (BeamSqlBackendValueSyntax be)) table)

default_ :: BeamSqlBackend be => QGenExpr ctxt be s a

General query combinators

all_ :: (Database be db, BeamSqlBackend be) => DatabaseEntity be db (TableEntity table) -> Q be db s (table (QExpr be s))

Introduce all entries of a table into the Q monad

values_ :: forall be db s a. (Projectible be a, BeamSqlBackend be) => [a] -> Q be db s a

SQL VALUES clause. Introduce the elements of the given list as rows in a joined table.

allFromView_ :: (Database be db, Beamable table, BeamSqlBackend be) => DatabaseEntity be db (ViewEntity table) -> Q be db s (table (QExpr be s))

Introduce all entries of a view into the Q monad

join_ :: (Database be db, Table table, BeamSqlBackend be) => DatabaseEntity be db (TableEntity table) -> (table (QExpr be s) -> QExpr be s Bool) -> Q be db s (table (QExpr be s))

Introduce all entries of a table into the Q monad based on the given QExpr. The join condition is expected to return a Bool. For a version that takes SqlBool (a possibly UNKNOWN boolean, that maps more closely to the SQL standard), see join_'.

join_' :: (Database be db, Table table, BeamSqlBackend be) => DatabaseEntity be db (TableEntity table) -> (table (QExpr be s) -> QExpr be s SqlBool) -> Q be db s (table (QExpr be s))

Like join_, but accepting an ON condition that returns SqlBool

guard_ :: forall be db s. BeamSqlBackend be => QExpr be s Bool -> Q be db s ()

Only allow results for which the QGenExpr yields True. For a version that operates over possibly NULL SqlBools, see guard_'.

guard_' :: forall be db s. BeamSqlBackend be => QExpr be s SqlBool -> Q be db s ()

Only allow results for which the QGenExpr yields TRUE.

This function operates over SqlBool, which are like haskell Bools, except for the special UNKNOWN value that occurs when comparisons include NULL. For a version that operates over known non-NULL booleans, see guard_.

filter_ :: forall r be db s. BeamSqlBackend be => (r -> QExpr be s Bool) -> Q be db s r -> Q be db s r

Synonym for clause >>= \x -> guard_ (mkExpr x)>> pure x. Use filter_' for comparisons with SqlBool

filter_' :: forall r be db s. BeamSqlBackend be => (r -> QExpr be s SqlBool) -> Q be db s r -> Q be db s r

Synonym for clause >>= \x -> guard_' (mkExpr x)>> pure x. Use filter_ for comparisons with Bool

related_ :: forall be db rel s. (Database be db, Table rel, BeamSqlBackend be, HasTableEquality be (PrimaryKey rel)) => DatabaseEntity be db (TableEntity rel) -> PrimaryKey rel (QExpr be s) -> Q be db s (rel (QExpr be s))

Introduce all entries of the given table which are referenced by the given PrimaryKey

relatedBy_ :: forall be db rel s. (Database be db, Table rel, BeamSqlBackend be) => DatabaseEntity be db (TableEntity rel) -> (rel (QExpr be s) -> QExpr be s Bool) -> Q be db s (rel (QExpr be s))

Introduce all entries of the given table for which the expression (which can depend on the queried table returns true)

relatedBy_' :: forall be db rel s. (Database be db, Table rel, BeamSqlBackend be) => DatabaseEntity be db (TableEntity rel) -> (rel (QExpr be s) -> QExpr be s SqlBool) -> Q be db s (rel (QExpr be s))

Introduce all entries of the given table for which the expression (which can depend on the queried table returns true)

leftJoin_ :: forall s r be db. (BeamSqlBackend be, Projectible be r, ThreadRewritable (QNested s) r, Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s r)) => Q be db (QNested s) r -> (WithRewrittenThread (QNested s) s r -> QExpr be s Bool) -> Q be db s (Retag Nullable (WithRewrittenThread (QNested s) s r))

Introduce a table using a left join. The ON clause is required here.Because this is not an inner join, the resulting table is made nullable. This means that each field that would normally have type 'QExpr x' will now have type 'QExpr (Maybe x)'.

The ON condition given must return Bool. For a version that accepts an ON condition returning SqlBool, see leftJoin_'.

leftJoin_' :: forall s r be db. (BeamSqlBackend be, Projectible be r, ThreadRewritable (QNested s) r, Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s r)) => Q be db (QNested s) r -> (WithRewrittenThread (QNested s) s r -> QExpr be s SqlBool) -> Q be db s (Retag Nullable (WithRewrittenThread (QNested s) s r))

Like leftJoin_, but accepts an ON clause returning SqlBool.

perhaps_ :: forall s r be db. (Projectible be r, BeamSqlBackend be, ThreadRewritable (QNested s) r, Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s r)) => Q be db (QNested s) r -> Q be db s (Retag Nullable (WithRewrittenThread (QNested s) s r))

Introduce a table using a left join with no ON clause. Because this is not an inner join, the resulting table is made nullable. This means that each field that would normally have type 'QExpr x' will now have type 'QExpr (Maybe x)'.

outerJoin_ :: forall s a b be db. (BeamSqlBackend be, BeamSqlBackendSupportsOuterJoin be, Projectible be a, Projectible be b, ThreadRewritable (QNested s) a, ThreadRewritable (QNested s) b, Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s a), Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s b)) => Q be db (QNested s) a -> Q be db (QNested s) b -> ((WithRewrittenThread (QNested s) s a, WithRewrittenThread (QNested s) s b) -> QExpr be s Bool) -> Q be db s (Retag Nullable (WithRewrittenThread (QNested s) s a), Retag Nullable (WithRewrittenThread (QNested s) s b))

Outer join. every row of each table, returning NULL for any row of either table for which the join condition finds no related rows.

This expects a join expression returning Bool, for a version that accepts a SqlBool (a possibly UNKNOWN boolean, that maps more closely to the SQL standard), see outerJoin_'

outerJoin_' :: forall s a b be db. (BeamSqlBackend be, BeamSqlBackendSupportsOuterJoin be, Projectible be a, Projectible be b, ThreadRewritable (QNested s) a, ThreadRewritable (QNested s) b, Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s a), Retaggable (QExpr be s) (WithRewrittenThread (QNested s) s b)) => Q be db (QNested s) a -> Q be db (QNested s) b -> ((WithRewrittenThread (QNested s) s a, WithRewrittenThread (QNested s) s b) -> QExpr be s SqlBool) -> Q be db s (Retag Nullable (WithRewrittenThread (QNested s) s a), Retag Nullable (WithRewrittenThread (QNested s) s b))

Like outerJoin_, but accepting SqlBool. Pairs of rows for which the join condition is unknown are considered to be unrelated, by SQL compliant databases at least.

subselect_ :: forall s r be db. (ThreadRewritable (QNested s) r, Projectible be r) => Q be db (QNested s) r -> Q be db s (WithRewrittenThread (QNested s) s r)

references_ :: (Table t, BeamSqlBackend be, HasTableEquality be (PrimaryKey t)) => PrimaryKey t (QGenExpr ctxt be s) -> t (QGenExpr ctxt be s) -> QGenExpr ctxt be s Bool

Generate an appropriate boolean QGenExpr comparing the given foreign key to the given table. Useful for creating join conditions. Use references_' for a SqlBool comparison.

references_' :: (Table t, BeamSqlBackend be, HasTableEquality be (PrimaryKey t)) => PrimaryKey t (QGenExpr ctxt be s) -> t (QGenExpr ctxt be s) -> QGenExpr ctxt be s SqlBool

Generate an appropriate boolean QGenExpr comparing the given foreign key to the given table. Useful for creating join conditions. Use references_ for a Bool comparison.

nub_ :: (BeamSqlBackend be, Projectible be r) => Q be db s r -> Q be db s r

Only return distinct values from a query

class SqlJustable a b | b -> a where

Type class for things that can be nullable. This includes 'QExpr (Maybe a)', 'tbl (Nullable QExpr)', and 'PrimaryKey tbl (Nullable QExpr)'

Methods

just_ :: a -> b

Given something of type 'QExpr a', 'tbl QExpr', or 'PrimaryKey tbl QExpr', turn it into a 'QExpr (Maybe a)', 'tbl (Nullable QExpr)', or 'PrimaryKey t (Nullable QExpr)' respectively that contains the same values.

nothing_ :: b

Return either a 'QExpr (Maybe x)' representing Nothing or a nullable Table or PrimaryKey filled with Nothing.

Instances

Table t => SqlJustable (t Identity) (t (Nullable Identity))

Defined in Database.Beam.Query.Combinators

Methods

just_ :: t Identity -> t (Nullable Identity)

nothing_ :: t (Nullable Identity)

(Table t, BeamSqlBackend be) => SqlJustable (t (QExpr be s)) (t (Nullable (QExpr be s)))

Defined in Database.Beam.Query.Combinators

Methods

just_ :: t (QExpr be s) -> t (Nullable (QExpr be s))

nothing_ :: t (Nullable (QExpr be s))

Table t => SqlJustable (PrimaryKey t Identity) (PrimaryKey t (Nullable Identity))

Defined in Database.Beam.Query.Combinators

Methods

just_ :: PrimaryKey t Identity -> PrimaryKey t (Nullable Identity)

nothing_ :: PrimaryKey t (Nullable Identity)

(Table t, BeamSqlBackend be) => SqlJustable (PrimaryKey t (QExpr be s)) (PrimaryKey t (Nullable (QExpr be s)))

Defined in Database.Beam.Query.Combinators

Methods

just_ :: PrimaryKey t (QExpr be s) -> PrimaryKey t (Nullable (QExpr be s))

nothing_ :: PrimaryKey t (Nullable (QExpr be s))

BeamSqlBackend be => SqlJustable (QExpr be s a) (QExpr be s (Maybe a))

Defined in Database.Beam.Query.Combinators

Methods

just_ :: QExpr be s a -> QExpr be s (Maybe a)

nothing_ :: QExpr be s (Maybe a)

class BeamSqlBackend be => SqlDeconstructMaybe be a nonNullA s | a s -> be, a -> nonNullA, a -> s, nonNullA -> s where

Type class for anything which can be checked for null-ness. This includes 'QExpr (Maybe a)' as well as Tables or PrimaryKeys over 'Nullable QExpr'.

Methods

isJust_ :: a -> QGenExpr ctxt be s Bool

Returns a QGenExpr that evaluates to true when the first argument is not null

isNothing_ :: a -> QGenExpr ctxt be s Bool

Returns a QGenExpr that evaluates to true when the first argument is null

maybe_ :: QGenExpr ctxt be s y -> (nonNullA -> QGenExpr ctxt be s y) -> a -> QGenExpr ctxt be s y

Given an object (third argument) which may or may not be null, return the default value if null (first argument), or transform the value that could be null to yield the result of the expression (second argument)

Instances

(BeamSqlBackend be, Beamable t) => SqlDeconstructMaybe be (t (Nullable (QGenExpr ctxt be s))) (t (QGenExpr ctxt be s)) s

Defined in Database.Beam.Query.Combinators

Methods

isJust_ :: t (Nullable (QGenExpr ctxt be s)) -> QGenExpr ctxt0 be s Bool

isNothing_ :: t (Nullable (QGenExpr ctxt be s)) -> QGenExpr ctxt0 be s Bool

maybe_ :: QGenExpr ctxt0 be s y -> (t (QGenExpr ctxt be s) -> QGenExpr ctxt0 be s y) -> t (Nullable (QGenExpr ctxt be s)) -> QGenExpr ctxt0 be s y

BeamSqlBackend be => SqlDeconstructMaybe be (QGenExpr ctxt be s (Maybe x)) (QGenExpr ctxt be s x) s

Defined in Database.Beam.Query.Combinators

Methods

isJust_ :: QGenExpr ctxt be s (Maybe x) -> QGenExpr ctxt0 be s Bool

isNothing_ :: QGenExpr ctxt be s (Maybe x) -> QGenExpr ctxt0 be s Bool

maybe_ :: QGenExpr ctxt0 be s y -> (QGenExpr ctxt be s x -> QGenExpr ctxt0 be s y) -> QGenExpr ctxt be s (Maybe x) -> QGenExpr ctxt0 be s y

class SqlOrderable be a | a -> be

Minimal complete definition

makeSQLOrdering

Instances

SqlOrderable be a => SqlOrderable be [a]

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: Proxy be -> [a] -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]

(SqlOrderable be a, SqlOrderable be b) => SqlOrderable be (a, b)

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: Proxy be -> (a, b) -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]

SqlOrderable be (QOrd be s a)

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: Proxy be -> QOrd be s a -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]

(SqlOrderable be a, SqlOrderable be b, SqlOrderable be c) => SqlOrderable be (a, b, c)

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: Proxy be -> (a, b, c) -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]

(TypeError ('Text "Missing mandatory sorting order. Use either 'asc_' or 'desc_' to specify sorting order.") :: Constraint) => SqlOrderable be (QGenExpr ctx be s a)

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: Proxy be -> QGenExpr ctx be s a -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]

(SqlOrderable be a, SqlOrderable be b, SqlOrderable be c, SqlOrderable be d) => SqlOrderable be (a, b, c, d)

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: Proxy be -> (a, b, c, d) -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]

(SqlOrderable be a, SqlOrderable be b, SqlOrderable be c, SqlOrderable be d, SqlOrderable be e) => SqlOrderable be (a, b, c, d, e)

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: Proxy be -> (a, b, c, d, e) -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]

(SqlOrderable be a, SqlOrderable be b, SqlOrderable be c, SqlOrderable be d, SqlOrderable be e, SqlOrderable be f) => SqlOrderable be (a, b, c, d, e, f)

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: Proxy be -> (a, b, c, d, e, f) -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]

(SqlOrderable be a, SqlOrderable be b, SqlOrderable be c, SqlOrderable be d, SqlOrderable be e, SqlOrderable be f, SqlOrderable be g) => SqlOrderable be (a, b, c, d, e, f, g)

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: Proxy be -> (a, b, c, d, e, f, g) -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]

(SqlOrderable be a, SqlOrderable be b, SqlOrderable be c, SqlOrderable be d, SqlOrderable be e, SqlOrderable be f, SqlOrderable be g, SqlOrderable be h) => SqlOrderable be (a, b, c, d, e, f, g, h)

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: Proxy be -> (a, b, c, d, e, f, g, h) -> [WithExprContext (BeamSqlBackendOrderingSyntax be)]

data QIfCond context be s a

data QIfElse context be s a

(<|>.) :: (SqlJustable a (QGenExpr ctxt syntax s y), SqlDeconstructMaybe syntax (QGenExpr ctxt syntax s y) a s) => QGenExpr ctxt syntax s y -> QGenExpr ctxt syntax s y -> QGenExpr ctxt syntax s y infixl 3

limit_ :: forall s a be db. (Projectible be a, ThreadRewritable (QNested s) a) => Integer -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)

Limit the number of results returned by a query.

offset_ :: forall s a be db. (Projectible be a, ThreadRewritable (QNested s) a) => Integer -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)

Drop the first offset' results.

as_ :: forall a ctxt be s. QGenExpr ctxt be s a -> QGenExpr ctxt be s a

Convenience function that allows you to use type applications to specify the result of a QGenExpr.

Useful to disambiguate the types of QGenExprs without having to provide a complete type signature. As an example, the countAll_ aggregate can return a result of any Integral type. Without further constraints, the type is ambiguous. You can use as_ to disambiguate the return type.

For example, this is ambiguous

aggregate_ (\_ -> countAll_) ..

But this is not

aggregate_ (\_ -> as_ @Int32 countAll_) ..

Subqueries

exists_ :: (BeamSqlBackend be, HasQBuilder be, Projectible be a) => Q be db s a -> QExpr be s Bool

Use the SQL EXISTS operator to determine if the given query returns any results

unique_ :: (BeamSqlBackend be, HasQBuilder be, Projectible be a) => Q be db s a -> QExpr be s Bool

Use the SQL UNIQUE operator to determine if the given query produces a unique result

distinct_ :: (BeamSqlBackend be, BeamSql99ExpressionBackend be, HasQBuilder be, Projectible be a) => Q be db s a -> QExpr be s Bool

Use the SQL99 DISTINCT operator to determine if the given query produces a distinct result

subquery_ :: (BeamSqlBackend be, HasQBuilder be, Projectible be (QExpr be s a)) => Q be db s (QExpr be s a) -> QGenExpr ctxt be s a

Project the (presumably) singular result of the given query as an expression

Set operations

Q values can be combined using a variety of set operations. See the manual section.

union_ :: forall be db s a. (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)

SQL UNION operator

unionAll_ :: forall be db s a. (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)

SQL UNION ALL operator

intersect_ :: forall be db s a. (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)

SQL INTERSECT operator

intersectAll_ :: forall be db s a. (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)

SQL INTERSECT ALL operator

except_ :: forall be db s a. (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)

SQL EXCEPT operator

exceptAll_ :: forall be db s a. (BeamSqlBackend be, Projectible be a, ThreadRewritable (QNested s) a) => Q be db (QNested s) a -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)

SQL EXCEPT ALL operator

Window functions

See the corresponding manual section for more.

over_ :: BeamSql2003ExpressionBackend be => QAgg be s a -> QWindow be s -> QWindowExpr be s a

Produce a window expression given an aggregate function and a window.

frame_

Arguments

:: forall be ordering partition s. (BeamSql2003ExpressionBackend be, SqlOrderable be ordering, Projectible be partition)

=> Maybe partition

PARTITION BY

-> Maybe ordering

ORDER BY

-> QFrameBounds be

RANGE / ROWS

-> QWindow be s

Specify a window frame with all the options

bounds_ :: BeamSql2003ExpressionBackend be => QFrameBound be -> Maybe (QFrameBound be) -> QFrameBounds be

unbounded_ :: BeamSql2003ExpressionBackend be => QFrameBound be

nrows_ :: BeamSql2003ExpressionBackend be => Int -> QFrameBound be

fromBound_ :: BeamSql2003ExpressionBackend be => QFrameBound be -> QFrameBounds be

noBounds_ :: QFrameBounds be

noOrder_ :: Integral a => Maybe (QOrd be s a)

noPartition_ :: Integral a => Maybe (QExpr be s a)

partitionBy_ :: partition -> Maybe partition

orderPartitionBy_ :: partition -> Maybe partition

withWindow_

Arguments

:: forall window a s r be db. (ProjectibleWithPredicate WindowFrameContext be (WithExprContext (BeamSqlBackendWindowFrameSyntax' be)) window, Projectible be r, Projectible be a, ContextRewritable a, ThreadRewritable (QNested s) (WithRewrittenContext a QValueContext))

=> (r -> window)

Window builder function

-> (r -> window -> a)

Projection builder function. Has access to the windows generated above

-> Q be db (QNested s) r

Query to window over

-> Q be db s (WithRewrittenThread (QNested s) s (WithRewrittenContext a QValueContext))

Compute a query over windows.

The first function builds window frames using the frame_, partitionBy_, etc functions. The return type can be a single frame, tuples of frame, or any arbitrarily nested tuple of the above. Instances up to 8-tuples are provided.

The second function builds the resulting projection using the result of the subquery as well as the window frames built in the first function. In this function, window expressions can be included in the output using the over_ function.

Ordering primitives

orderBy_ :: forall s a ordering be db. (Projectible be a, SqlOrderable be ordering, ThreadRewritable (QNested s) a) => (a -> ordering) -> Q be db (QNested s) a -> Q be db s (WithRewrittenThread (QNested s) s a)

Order by the given expressions. The return type of the ordering key should either be the result of asc_ or desc_ (or another ordering QOrd generated by a backend-specific ordering) or an (possibly nested) tuple of results of the former.

The manual section has more information.

asc_ :: forall be s a. BeamSqlBackend be => QExpr be s a -> QOrd be s a

Produce a QOrd corresponding to a SQL ASC ordering

desc_ :: forall be s a. BeamSqlBackend be => QExpr be s a -> QOrd be s a

Produce a QOrd corresponding to a SQL DESC ordering

nullsFirst_ :: IsSql2003OrderingElementaryOLAPOperationsSyntax (BeamSqlBackendOrderingSyntax be) => QOrd be s a -> QOrd be s a

nullsLast_ :: IsSql2003OrderingElementaryOLAPOperationsSyntax (BeamSqlBackendOrderingSyntax be) => QOrd be s a -> QOrd be s a

Various combinators corresponding to SQL extensions

T614 NTILE function

ntile_ :: (BeamSqlBackend be, BeamSqlT614Backend be, Integral n) => QExpr be s n -> QAgg be s a

T615 LEAD and LAG function

lead1_ :: (BeamSqlBackend be, BeamSqlT615Backend be) => QExpr be s a -> QAgg be s a

lag1_ :: (BeamSqlBackend be, BeamSqlT615Backend be) => QExpr be s a -> QAgg be s a

lead_ :: (BeamSqlBackend be, BeamSqlT615Backend be, Integral n) => QExpr be s a -> QExpr be s n -> QAgg be s a

lag_ :: (BeamSqlBackend be, BeamSqlT615Backend be, Integral n) => QExpr be s a -> QExpr be s n -> QAgg be s a

leadWithDefault_ :: (BeamSqlBackend be, BeamSqlT615Backend be, Integral n) => QExpr be s a -> QExpr be s n -> QExpr be s a -> QAgg be s a

lagWithDefault_ :: (BeamSqlBackend be, BeamSqlT615Backend be, Integral n) => QExpr be s a -> QExpr be s n -> QExpr be s a -> QAgg be s a

T616 FIRST_VALUE and LAST_VALUE functions

firstValue_ :: (BeamSqlBackend be, BeamSqlT616Backend be) => QExpr be s a -> QAgg be s a

lastValue_ :: (BeamSqlBackend be, BeamSqlT616Backend be) => QExpr be s a -> QAgg be s a

T618 NTH_VALUE function

nthValue_ :: (BeamSqlBackend be, BeamSqlT618Backend be, Integral n) => QExpr be s a -> QExpr be s n -> QAgg be s a

T621 Enhanced numeric functions

(**.) :: (Floating a, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s a -> QGenExpr ctxt be s a infixr 8

ln_ :: (Floating a, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s a

exp_ :: (Floating a, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s a

sqrt_ :: (Floating a, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s a

ceiling_ :: (RealFrac a, Integral b, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s b

floor_ :: (RealFrac a, Integral b, BeamSqlBackend be, BeamSqlT621Backend be) => QGenExpr ctxt be s a -> QGenExpr ctxt be s b

stddevPopOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s b

stddevSampOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s b

varPopOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s b

varSampOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s b

stddevPop_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QAgg be s b

stddevSamp_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QAgg be s b

varPop_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QAgg be s b

varSamp_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QAgg be s b

covarPopOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b

covarSampOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b

corrOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b

regrSlopeOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b

regrInterceptOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b

regrCountOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b

regrRSquaredOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b

regrAvgXOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b

regrAvgYOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b

regrSXXOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b

regrSYYOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b

regrSXYOver_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QExpr be s a -> QExpr be s b

covarPop_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b

covarSamp_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b

corr_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b

regrSlope_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b

regrIntercept_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b

regrCount_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b

regrRSquared_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b

regrAvgX_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b

regrAvgY_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b

regrSXX_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b

regrSYY_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b

regrSXY_ :: (Num a, Floating b, BeamSqlBackend be, BeamSqlT621Backend be) => QExpr be s a -> QExpr be s a -> QExpr be s b

Relationships

Many-to-many relationships

type ManyToMany be db left right = forall s. (BeamSqlBackend be, SqlEq (QExpr be s) (PrimaryKey left (QExpr be s)), SqlEq (QExpr be s) (PrimaryKey right (QExpr be s))) => Q be db s (left (QExpr be s)) -> Q be db s (right (QExpr be s)) -> Q be db s (left (QExpr be s), right (QExpr be s))

Convenience type to declare many-to-many relationships. See the manual section on relationships for more information

type ManyToManyThrough be db through left right = forall s. (BeamSqlBackend be, SqlEq (QExpr be s) (PrimaryKey left (QExpr be s)), SqlEq (QExpr be s) (PrimaryKey right (QExpr be s))) => Q be db s (left (QExpr be s)) -> Q be db s (right (QExpr be s)) -> Q be db s (through (QExpr be s), left (QExpr be s), right (QExpr be s))

Convenience type to declare many-to-many relationships with additional data. See the manual section on relationships for more information

manyToMany_ :: (Database be db, Table joinThrough, Table left, Table right, BeamSqlBackend be, SqlEq (QExpr be s) (PrimaryKey left (QExpr be s)), SqlEq (QExpr be s) (PrimaryKey right (QExpr be s))) => DatabaseEntity be db (TableEntity joinThrough) -> (joinThrough (QExpr be s) -> PrimaryKey left (QExpr be s)) -> (joinThrough (QExpr be s) -> PrimaryKey right (QExpr be s)) -> Q be db s (left (QExpr be s)) -> Q be db s (right (QExpr be s)) -> Q be db s (left (QExpr be s), right (QExpr be s))

Used to define many-to-many relationships without any additional data. Takes the join table and two key extraction functions from that table to the related tables. Also takes two Qs representing the table sources to relate.

See the manual for more information.

manyToManyPassthrough_ :: (Database be db, Table joinThrough, Table left, Table right, BeamSqlBackend be, SqlEq (QExpr be s) (PrimaryKey left (QExpr be s)), SqlEq (QExpr be s) (PrimaryKey right (QExpr be s))) => DatabaseEntity be db (TableEntity joinThrough) -> (joinThrough (QExpr be s) -> PrimaryKey left (QExpr be s)) -> (joinThrough (QExpr be s) -> PrimaryKey right (QExpr be s)) -> Q be db s (left (QExpr be s)) -> Q be db s (right (QExpr be s)) -> Q be db s (joinThrough (QExpr be s), left (QExpr be s), right (QExpr be s))

Used to define many-to-many relationships with additional data. Takes the join table and two key extraction functions from that table to the related tables. Also takes two Qs representing the table sources to relate.

See the manual for more information.

One-to-many relationships

type OneToMany be db s one many = (BeamSqlBackend be, BeamSqlBackendCanSerialize be Bool) => one (QExpr be s) -> Q be db s (many (QExpr be s))

Convenience type to declare one-to-many relationships. See the manual section on relationships for more information

type OneToManyOptional be db s tbl rel = (BeamSqlBackend be, BeamSqlBackendCanSerialize be Bool, BeamSqlBackendCanSerialize be SqlNull) => tbl (QExpr be s) -> Q be db s (rel (Nullable (QExpr be s)))

Convenience type to declare one-to-many relationships with a nullable foreign key. See the manual section on relationships for more information

oneToMany_

Arguments

:: (Database be db, BeamSqlBackend be, HasTableEquality be (PrimaryKey tbl), Table tbl, Table rel)

=> DatabaseEntity be db (TableEntity rel)

Table to fetch (many)

-> (rel (QExpr be s) -> PrimaryKey tbl (QExpr be s))

Foreign key

-> tbl (QExpr be s)

-> Q be db s (rel (QExpr be s))

Used to define one-to-many (or one-to-one) relationships. Takes the table to fetch, a way to extract the foreign key from that table, and the table to relate to.

oneToManyOptional_

Arguments

:: (BeamSqlBackend be, Database be db, Table tbl, Table rel, HasTableEqualityNullable be (PrimaryKey tbl))

=> DatabaseEntity be db (TableEntity rel)

Table to fetch

-> (rel (QExpr be s) -> PrimaryKey tbl (Nullable (QExpr be s)))

Foreign key

-> tbl (QExpr be s)

-> Q be db s (rel (Nullable (QExpr be s)))

Used to define one-to-many (or one-to-one) relationships with a nullable foreign key. Takes the table to fetch, a way to extract the foreign key from that table, and the table to relate to.

One-to-one relationshships

type OneToOne be db s one many = OneToMany be db s one many

Synonym of OneToMany. Useful for giving more meaningful types, when the relationship is meant to be one-to-one.

type OneToMaybe be db s tbl rel = OneToManyOptional be db s tbl rel

Synonym of OneToManyOptional. Useful for giving more meaningful types, when the relationship is meant to be one-to-one.

oneToOne_

Arguments

:: (Database be db, BeamSqlBackend be, HasTableEquality be (PrimaryKey tbl), Table tbl, Table rel)

=> DatabaseEntity be db (TableEntity rel)

Table to fetch (many)

-> (rel (QExpr be s) -> PrimaryKey tbl (QExpr be s))

Foreign key

-> tbl (QExpr be s)

-> Q be db s (rel (QExpr be s))

Used to define one-to-many (or one-to-one) relationships. Takes the table to fetch, a way to extract the foreign key from that table, and the table to relate to.

oneToMaybe_

Arguments

:: (BeamSqlBackend be, Database be db, Table tbl, Table rel, HasTableEqualityNullable be (PrimaryKey tbl))

=> DatabaseEntity be db (TableEntity rel)

Table to fetch

-> (rel (QExpr be s) -> PrimaryKey tbl (Nullable (QExpr be s)))

Foreign key

-> tbl (QExpr be s)

-> Q be db s (rel (Nullable (QExpr be s)))

Used to define one-to-many (or one-to-one) relationships with a nullable foreign key. Takes the table to fetch, a way to extract the foreign key from that table, and the table to relate to.

data With be (db :: (Type -> Type) -> Type) a

Monad in which SELECT statements can be made (via selecting) and bound to result names for re-use later. This has the advantage of only computing each result once. In SQL, this is translated to a common table expression.

Once introduced, results can be re-used in future queries with reuse.

With is also a member of MonadFix for backends that support recursive CTEs. In this case, you can use mdo or rec notation (with RecursiveDo enabled) to bind result values (again, using reuse) even before they're introduced.

See further documentation here.

Instances

IsSql99RecursiveCommonTableExpressionSelectSyntax (BeamSqlBackendSelectSyntax be) => MonadFix (With be db)

Defined in Database.Beam.Query.CTE

Methods

mfix :: (a -> With be db a) -> With be db a

Applicative (With be db)

Defined in Database.Beam.Query.CTE

Methods

pure :: a -> With be db a

(<*>) :: With be db (a -> b) -> With be db a -> With be db b

liftA2 :: (a -> b -> c) -> With be db a -> With be db b -> With be db c

(*>) :: With be db a -> With be db b -> With be db b

(<*) :: With be db a -> With be db b -> With be db a

Functor (With be db)

Defined in Database.Beam.Query.CTE

Methods

fmap :: (a -> b) -> With be db a -> With be db b

(<$) :: a -> With be db b -> With be db a

Monad (With be db)

Defined in Database.Beam.Query.CTE

Methods

(>>=) :: With be db a -> (a -> With be db b) -> With be db b

(>>) :: With be db a -> With be db b -> With be db b

return :: a -> With be db a

data ReusableQ be db res

Query results that have been introduced into a common table expression via selecting that can be used in future queries with reuse.

selecting :: forall res be db. (BeamSql99CommonTableExpressionBackend be, HasQBuilder be, Projectible be res, ThreadRewritable QAnyScope res) => Q be db QAnyScope res -> With be db (ReusableQ be db res)

Introduce the result of a query as a result in a common table expression. The returned value can be used in future queries by applying reuse.

reuse :: forall s be db res. ReusableQ be db res -> Q be db s (WithRewrittenThread QAnyScope s res)

Introduces the result of a previous selecting (a CTE) into a new query

SQL EXTRACT support

newtype ExtractField be tgt a

A field that can be extracted from SQL expressions of type tgt that results in a type a, in backend be.

Constructors

ExtractField (Sql92ExtractFieldSyntax (BeamSqlBackendSyntax be))

extract_ :: BeamSqlBackend be => ExtractField be tgt a -> QGenExpr ctxt be s tgt -> QGenExpr cxt be s a

Extracts the given field from the target expression

SQL92 fields

hour_ :: (BeamSqlBackend be, HasSqlTime tgt) => ExtractField be tgt Double

Extracts the hours, minutes, or seconds from any timestamp or time field

minutes_ :: (BeamSqlBackend be, HasSqlTime tgt) => ExtractField be tgt Double

Extracts the hours, minutes, or seconds from any timestamp or time field

seconds_ :: (BeamSqlBackend be, HasSqlTime tgt) => ExtractField be tgt Double

Extracts the hours, minutes, or seconds from any timestamp or time field

year_ :: (BeamSqlBackend be, HasSqlDate tgt) => ExtractField be tgt Double

month_ :: (BeamSqlBackend be, HasSqlDate tgt) => ExtractField be tgt Double

day_ :: (BeamSqlBackend be, HasSqlDate tgt) => ExtractField be tgt Double

class HasSqlTime tgt

Type-class for types that contain a time component

Instances

HasSqlTime UTCTime

Defined in Database.Beam.Query.Extract

HasSqlTime LocalTime

Defined in Database.Beam.Query.Extract

HasSqlTime TimeOfDay

Defined in Database.Beam.Query.Extract

class HasSqlDate tgt

Type-class for types that contain a date component

Instances

HasSqlDate Day

Defined in Database.Beam.Query.Extract

HasSqlDate UTCTime

Defined in Database.Beam.Query.Extract

HasSqlDate LocalTime

Defined in Database.Beam.Query.Extract

Operators

data SqlBool

Phantom type representing a SQL Tri-state boolean -- true, false, and unknown

This type has no values because it cannot be sent to or retrieved from the database directly. Use isTrue_, isFalse_, isNotTrue_, isNotFalse_, isUnknown_, isNotUnknown_, and unknownAs_ to retrieve the corresponding Bool value.

General-purpose operators

(&&.) :: BeamSqlBackend be => QGenExpr context be s Bool -> QGenExpr context be s Bool -> QGenExpr context be s Bool infixr 3

SQL AND operator

(||.) :: BeamSqlBackend be => QGenExpr context be s Bool -> QGenExpr context be s Bool -> QGenExpr context be s Bool infixr 2

SQL OR operator

not_ :: forall be context s. BeamSqlBackend be => QGenExpr context be s Bool -> QGenExpr context be s Bool

SQL NOT operator

div_ :: (Integral a, BeamSqlBackend be) => QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a infixl 7

SQL / operator

mod_ :: (Integral a, BeamSqlBackend be) => QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a infixl 7

SQL % operator

(&&?.) :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s SqlBool -> QGenExpr context be s SqlBool infixr 3

SQL AND operator for SqlBool

(||?.) :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s SqlBool -> QGenExpr context be s SqlBool infixr 2

SQL OR operator

sqlNot_ :: forall be context s. BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s SqlBool

SQL NOT operator, but operating on SqlBool instead

like_ :: (BeamSqlBackendIsString be text, BeamSqlBackend be) => QGenExpr ctxt be s text -> QGenExpr ctxt be s text -> QGenExpr ctxt be s Bool infix 4

SQL LIKE operator

similarTo_ :: (BeamSqlBackendIsString be text, BeamSql99ExpressionBackend be) => QGenExpr ctxt be s text -> QGenExpr ctxt be s text -> QGenExpr ctxt be s text infix 4

SQL99 SIMILAR TO operator

like_' :: (BeamSqlBackendIsString be left, BeamSqlBackendIsString be right, BeamSqlBackend be) => QGenExpr ctxt be s left -> QGenExpr ctxt be s right -> QGenExpr ctxt be s Bool

SQL LIKE operator but heterogeneous over the text type

similarTo_' :: (BeamSqlBackendIsString be left, BeamSqlBackendIsString be right, BeamSql99ExpressionBackend be) => QGenExpr ctxt be s left -> QGenExpr ctxt be s right -> QGenExpr ctxt be s left

SQL99 SIMILAR TO operator but heterogeneous over the text type

concat_ :: BeamSql99ConcatExpressionBackend be => [QGenExpr context be s Text] -> QGenExpr context be s Text

SQL CONCAT function

ANSI SQL Booleans

isTrue_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool

SQL IS TRUE operator

isNotTrue_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool

SQL IS NOT TRUE operator

isFalse_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool

SQL IS FALSE operator

isNotFalse_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool

SQL IS NOT FALSE operator

isUnknown_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool

SQL IS UNKNOWN operator

isNotUnknown_ :: BeamSqlBackend be => QGenExpr context be s SqlBool -> QGenExpr context be s Bool

SQL IS NOT UNKNOWN operator

unknownAs_ :: BeamSqlBackend be => Bool -> QGenExpr context be s SqlBool -> QGenExpr context be s Bool

Return the first argument if the expression has the unknown SQL value See sqlBool_ for the inverse

sqlBool_ :: QGenExpr context syntax s Bool -> QGenExpr context syntax s SqlBool

Convert a known not null bool to a SqlBool. See unknownAs_ for the inverse

possiblyNullBool_ :: QGenExpr context be s SqlBool -> QGenExpr context be s (Maybe Bool)

Retrieve a SqlBool value as a potentially NULL Bool. This is useful if you want to get the value of a SQL boolean expression directly, without having to specify what to do on UNKNOWN. Note that both NULL and UNKNOWN will be returned as Nothing.

fromPossiblyNullBool_ :: QGenExpr context be s (Maybe Bool) -> QGenExpr context be s SqlBool

Convert a possibly NULL Bool to a SqlBool.

Unquantified comparison operators

class BeamSqlBackend be => HasSqlEqualityCheck be a where

Class for Haskell types that can be compared for equality in the given backend

Minimal complete definition

Nothing

Methods

sqlEqE :: Proxy a -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be

sqlNeqE :: Proxy a -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be

sqlEqTriE :: Proxy a -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be

Tri-state equality

sqlNeqTriE :: Proxy a -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be

Tri-state equality

Instances

HasSqlEqualityCheck be a => HasSqlEqualityCheck be (SqlSerial a)

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy (SqlSerial a) -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be

sqlNeqE :: Proxy (SqlSerial a) -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be

sqlEqTriE :: Proxy (SqlSerial a) -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be

sqlNeqTriE :: Proxy (SqlSerial a) -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be

(HasSqlEqualityCheck be a, CanCheckMaybeEquality a) => HasSqlEqualityCheck be (Maybe a)

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy (Maybe a) -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be

sqlNeqE :: Proxy (Maybe a) -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be

sqlEqTriE :: Proxy (Maybe a) -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be

sqlNeqTriE :: Proxy (Maybe a) -> Proxy be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Int16

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Int16 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy Int16 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy Int16 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy Int16 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Int32

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Int32 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy Int32 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy Int32 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy Int32 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Int64

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Int64 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy Int64 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy Int64 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy Int64 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Int8

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Int8 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy Int8 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy Int8 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy Int8 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Word16

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Word16 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy Word16 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy Word16 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy Word16 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Word32

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Word32 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy Word32 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy Word32 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy Word32 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Word64

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Word64 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy Word64 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy Word64 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy Word64 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Word8

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Word8 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy Word8 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy Word8 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy Word8 -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Text

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Text -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy Text -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy Text -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy Text -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Day

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Day -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy Day -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy Day -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy Day -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) UTCTime

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy UTCTime -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy UTCTime -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy UTCTime -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy UTCTime -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) LocalTime

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy LocalTime -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy LocalTime -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy LocalTime -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy LocalTime -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) TimeOfDay

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy TimeOfDay -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy TimeOfDay -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy TimeOfDay -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy TimeOfDay -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Integer

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Integer -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy Integer -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy Integer -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy Integer -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Bool

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Bool -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy Bool -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy Bool -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy Bool -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Double

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Double -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy Double -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy Double -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy Double -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Float

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Float -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy Float -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy Float -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy Float -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Int

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Int -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy Int -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy Int -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy Int -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlEqualityCheck (MockSqlBackend cmd) Word

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Word -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy Word -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy Word -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy Word -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

(BeamSqlBackend (MockSqlBackend cmd), HasSqlEqualityCheck (MockSqlBackend cmd) a) => HasSqlEqualityCheck (MockSqlBackend cmd) (Tagged t a)

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy (Tagged t a) -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqE :: Proxy (Tagged t a) -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlEqTriE :: Proxy (Tagged t a) -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlNeqTriE :: Proxy (Tagged t a) -> Proxy (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

class HasSqlEqualityCheck be a => HasSqlQuantifiedEqualityCheck be a where

Class for Haskell types that can be compared for quantified equality in the given backend

Minimal complete definition

Nothing

Methods

sqlQEqE :: Proxy a -> Proxy be -> Maybe (BeamSqlBackendExpressionQuantifierSyntax be) -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be

sqlQNeqE :: Proxy a -> Proxy be -> Maybe (BeamSqlBackendExpressionQuantifierSyntax be) -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be -> BeamSqlBackendExpressionSyntax be

Instances

HasSqlQuantifiedEqualityCheck syntax a => HasSqlQuantifiedEqualityCheck syntax (SqlSerial a)

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy (SqlSerial a) -> Proxy syntax -> Maybe (BeamSqlBackendExpressionQuantifierSyntax syntax) -> BeamSqlBackendExpressionSyntax syntax -> BeamSqlBackendExpressionSyntax syntax -> BeamSqlBackendExpressionSyntax syntax

sqlQNeqE :: Proxy (SqlSerial a) -> Proxy syntax -> Maybe (BeamSqlBackendExpressionQuantifierSyntax syntax) -> BeamSqlBackendExpressionSyntax syntax -> BeamSqlBackendExpressionSyntax syntax -> BeamSqlBackendExpressionSyntax syntax

(HasSqlQuantifiedEqualityCheck syntax a, CanCheckMaybeEquality a) => HasSqlQuantifiedEqualityCheck syntax (Maybe a)

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy (Maybe a) -> Proxy syntax -> Maybe (BeamSqlBackendExpressionQuantifierSyntax syntax) -> BeamSqlBackendExpressionSyntax syntax -> BeamSqlBackendExpressionSyntax syntax -> BeamSqlBackendExpressionSyntax syntax

sqlQNeqE :: Proxy (Maybe a) -> Proxy syntax -> Maybe (BeamSqlBackendExpressionQuantifierSyntax syntax) -> BeamSqlBackendExpressionSyntax syntax -> BeamSqlBackendExpressionSyntax syntax -> BeamSqlBackendExpressionSyntax syntax

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Int16

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Int16 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy Int16 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Int32

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Int32 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy Int32 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Int64

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Int64 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy Int64 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Int8

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Int8 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy Int8 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Word16

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Word16 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy Word16 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Word32

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Word32 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy Word32 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Word64

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Word64 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy Word64 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Word8

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Word8 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy Word8 -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Text

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Text -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy Text -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Day

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Day -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy Day -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) UTCTime

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy UTCTime -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy UTCTime -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) LocalTime

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy LocalTime -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy LocalTime -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) TimeOfDay

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy TimeOfDay -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy TimeOfDay -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Integer

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Integer -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy Integer -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Bool

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Bool -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy Bool -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Double

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Double -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy Double -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Float

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Float -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy Float -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Int

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Int -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy Int -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

BeamSqlBackend (MockSqlBackend cmd) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) Word

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Word -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy Word -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

(BeamSqlBackend (MockSqlBackend cmd), HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) a) => HasSqlQuantifiedEqualityCheck (MockSqlBackend cmd) (Tagged t a)

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy (Tagged t a) -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

sqlQNeqE :: Proxy (Tagged t a) -> Proxy (MockSqlBackend cmd) -> Maybe (BeamSqlBackendExpressionQuantifierSyntax (MockSqlBackend cmd)) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd) -> BeamSqlBackendExpressionSyntax (MockSqlBackend cmd)

type HasTableEquality be tbl = (FieldsFulfillConstraint (HasSqlEqualityCheck be) tbl, Beamable tbl)

Constraint synonym to check if two tables can be compared for equality

class SqlEq expr a | a -> expr where

Class for expression types or expression containers for which there is a notion of equality.

Instances are provided to check the equality of expressions of the same type as well as entire Beamable types parameterized over QGenExpr

Methods

(==.) :: a -> a -> expr Bool infix 4

Given two expressions, returns whether they are equal, using Haskell semantics (NULLs handled properly)

(/=.) :: a -> a -> expr Bool infix 4

Given two expressions, returns whether they are not equal, using Haskell semantics (NULLs handled properly)

(==?.) :: a -> a -> expr SqlBool infix 4

Given two expressions, returns the SQL tri-state boolean when compared for equality

(/=?.) :: a -> a -> expr SqlBool infix 4

Given two expressions, returns the SQL tri-state boolean when compared for inequality

Instances

(BeamSqlBackend be, Beamable tbl, FieldsFulfillConstraintNullable (HasSqlEqualityCheck be) tbl) => SqlEq (QGenExpr context be s) (tbl (Nullable (QGenExpr context be s)))

Defined in Database.Beam.Query.Ord

Methods

(==.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s Bool

(/=.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s Bool

(==?.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s SqlBool

(/=?.) :: tbl (Nullable (QGenExpr context be s)) -> tbl (Nullable (QGenExpr context be s)) -> QGenExpr context be s SqlBool

(BeamSqlBackend be, Beamable tbl, FieldsFulfillConstraint (HasSqlEqualityCheck be) tbl) => SqlEq (QGenExpr context be s) (tbl (QGenExpr context be s))

Compare two arbitrary Beamable types containing QGenExprs for equality.

Defined in Database.Beam.Query.Ord

Methods

(==.) :: tbl (QGenExpr context be s) -> tbl (QGenExpr context be s) -> QGenExpr context be s Bool

(/=.) :: tbl (QGenExpr context be s) -> tbl (QGenExpr context be s) -> QGenExpr context be s Bool

(==?.) :: tbl (QGenExpr context be s) -> tbl (QGenExpr context be s) -> QGenExpr context be s SqlBool

(/=?.) :: tbl (QGenExpr context be s) -> tbl (QGenExpr context be s) -> QGenExpr context be s SqlBool

(BeamSqlBackend be, HasSqlEqualityCheck be a) => SqlEq (QGenExpr context be s) (QGenExpr context be s a)

Compare two arbitrary expressions (of the same type) for equality

Defined in Database.Beam.Query.Ord

Methods

(==.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool

(/=.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool

(==?.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s SqlBool

(/=?.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s SqlBool

class SqlOrd expr e | e -> expr where

Class for expression types or expression containers for which there is a notion of ordering.

Instances are provided to check the ordering of expressions of the same type. Since there is no universal notion of ordering for an arbitrary number of expressions, no instance is provided for Beamable types.

Methods

(<.) :: e -> e -> expr Bool infix 4

(>.) :: e -> e -> expr Bool infix 4

(<=.) :: e -> e -> expr Bool infix 4

(>=.) :: e -> e -> expr Bool infix 4

Instances

BeamSqlBackend be => SqlOrd (QGenExpr context be s) (QGenExpr context be s a)

Defined in Database.Beam.Query.Ord

Methods

(<.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool

(>.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool

(<=.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool

(>=.) :: QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool

class SqlIn expr a | a -> expr where

Methods

in_ :: a -> [a] -> expr Bool infix 4

SQL IN predicate

Instances

(HasSqlInTable be, Beamable table) => SqlIn (QGenExpr context be s) (table (QGenExpr context be s))

Defined in Database.Beam.Query.Ord

Methods

in_ :: table (QGenExpr context be s) -> [table (QGenExpr context be s)] -> QGenExpr context be s Bool

BeamSqlBackend be => SqlIn (QGenExpr context be s) (QGenExpr context be s a)

Defined in Database.Beam.Query.Ord

Methods

in_ :: QGenExpr context be s a -> [QGenExpr context be s a] -> QGenExpr context be s Bool

class BeamSqlBackend be => HasSqlInTable be where

Class for backends which support SQL IN on lists of row values, which is not part of ANSI SQL. This is useful for IN on primary keys.

Minimal complete definition

Nothing

Methods

inRowValuesE :: Proxy be -> BeamSqlBackendExpressionSyntax be -> [BeamSqlBackendExpressionSyntax be] -> BeamSqlBackendExpressionSyntax be

inQuery_ :: (HasQBuilder be, BeamSqlBackend be) => QGenExpr ctx be s a -> Q be db s (QExpr be s a) -> QGenExpr ctx be s Bool infix 4

Quantified Comparison Operators

class SqlEq expr a => SqlEqQuantified expr quantified a | a -> expr quantified where

Class for expression types for which there is a notion of quantified equality.

Methods

(==*.) :: a -> quantified -> expr SqlBool infix 4

Quantified equality and inequality using SQL semantics (tri-state boolean)

(/=*.) :: a -> quantified -> expr SqlBool infix 4

Quantified equality and inequality using SQL semantics (tri-state boolean)

Instances

(BeamSqlBackend be, HasSqlQuantifiedEqualityCheck be a) => SqlEqQuantified (QGenExpr context be s) (QQuantified be s a) (QGenExpr context be s a)

Two arbitrary expressions can be quantifiably compared for equality.

Defined in Database.Beam.Query.Ord

Methods

(==*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s SqlBool

(/=*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s SqlBool

class SqlOrd expr e => SqlOrdQuantified expr quantified e | e -> expr quantified where

Class for things which can be quantifiably compared.

Methods

(<*.) :: e -> quantified -> expr Bool infix 4

(>*.) :: e -> quantified -> expr Bool infix 4

(<=*.) :: e -> quantified -> expr Bool infix 4

(>=*.) :: e -> quantified -> expr Bool infix 4

Instances

BeamSqlBackend be => SqlOrdQuantified (QGenExpr context be s) (QQuantified be s a) (QGenExpr context be s a)

Defined in Database.Beam.Query.Ord

Methods

(<*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool

(>*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool

(<=*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool

(>=*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool

data QQuantified be s r

A data structure representing the set to quantify a comparison operator over.

Instances

(BeamSqlBackend be, HasSqlQuantifiedEqualityCheck be a) => SqlEqQuantified (QGenExpr context be s) (QQuantified be s a) (QGenExpr context be s a)

Two arbitrary expressions can be quantifiably compared for equality.

Defined in Database.Beam.Query.Ord

Methods

(==*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s SqlBool

(/=*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s SqlBool

BeamSqlBackend be => SqlOrdQuantified (QGenExpr context be s) (QQuantified be s a) (QGenExpr context be s a)

Defined in Database.Beam.Query.Ord

Methods

(<*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool

(>*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool

(<=*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool

(>=*.) :: QGenExpr context be s a -> QQuantified be s a -> QGenExpr context be s Bool

anyOf_ :: forall s a be db. (BeamSqlBackend be, HasQBuilder be) => Q be db (QNested s) (QExpr be (QNested s) a) -> QQuantified be s a

A QQuantified representing a SQL ANY(..) for use with a quantified comparison operator

Accepts a subquery. Use anyIn_ for an explicit list

allOf_ :: forall s a be db. (BeamSqlBackend be, HasQBuilder be) => Q be db (QNested s) (QExpr be (QNested s) a) -> QQuantified be s a

A QQuantified representing a SQL ALL(..) for use with a quantified comparison operator

Accepts a subquery. Use allIn_ for an explicit list

anyIn_ :: forall s a be. BeamSqlBackend be => [QExpr be s a] -> QQuantified be s a

A QQuantified representing a SQL ANY(..) for use with a quantified comparison operator

Accepts an explicit list of typed expressions. Use anyOf_ for a subquery

allIn_ :: forall s a be. BeamSqlBackend be => [QExpr be s a] -> QQuantified be s a

A QQuantified representing a SQL ALL(..) for use with a quantified comparison operator

Accepts an explicit list of typed expressions. Use allOf_ for a subquery

between_ :: BeamSqlBackend be => QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s a -> QGenExpr context be s Bool infix 4

SQL BETWEEN clause

Aggregates

See the corresponding manual section for more detail

aggregate_

Arguments

:: forall be a r db s. (BeamSqlBackend be, Aggregable be a, Projectible be r, Projectible be a, ContextRewritable a, ThreadRewritable (QNested s) (WithRewrittenContext a QValueContext))

=> (r -> a)

Aggregate projection

-> Q be db (QNested s) r

Query to aggregate over

-> Q be db s (WithRewrittenThread (QNested s) s (WithRewrittenContext a QValueContext))

Compute an aggregate over a query.

The supplied aggregate projection should return an aggregate expression (an expression containing an aggregate function such as count_, sum_, countAll_, etc), a grouping key (specified with the group_ function), or a combination of tuples of the above.

Appropriate instances are provided up to 8-tuples.

Semantically, all grouping expressions in the projection will be added to a SQL GROUP BY clause and all aggregate expressions will be computed.

The return value will be the type of the aggregate projection, but transformed to be in the normal value context (i.e., everything will become QGenExprs).

For usage examples, see the manual.

filterWhere_ :: BeamSqlT611Backend be => QAgg be s a -> QExpr be s Bool -> QAgg be s a

Support for FILTER (WHERE ...) syntax for aggregates. Part of SQL2003 Elementary OLAP operations feature (T611).

See filterWhere_' for a version that accepts SqlBool.

filterWhere_' :: BeamSqlT611Backend be => QAgg be s a -> QExpr be s SqlBool -> QAgg be s a

Like filterWhere_ but accepting SqlBool.

class QGroupable expr grouped | expr -> grouped, grouped -> expr where

Type class for grouping keys. expr is the type of the grouping key after projection. grouped is the type of the grouping key in the aggregate expression (usually something that contains QGenExprs in the QGroupingContext).

Methods

group_ :: expr -> grouped

Instances

Beamable tbl => QGroupable (tbl (Nullable (QExpr be s))) (tbl (Nullable (QGroupExpr be s)))

group_ for any Beamable type. Adds every field in the type to the grouping key. This is the equivalent of including the grouping expression of each field in the type as part of the aggregate projection

Defined in Database.Beam.Query.Aggregate

Methods

group_ :: tbl (Nullable (QExpr be s)) -> tbl (Nullable (QGroupExpr be s))

Beamable tbl => QGroupable (tbl (QExpr be s)) (tbl (QGroupExpr be s))

group_ for any Beamable type. Adds every field in the type to the grouping key. This is the equivalent of including the grouping expression of each field in the type as part of the aggregate projection

Defined in Database.Beam.Query.Aggregate

Methods

group_ :: tbl (QExpr be s) -> tbl (QGroupExpr be s)

QGroupable (QExpr be s a) (QGroupExpr be s a)

group_ for simple value expressions.

Defined in Database.Beam.Query.Aggregate

Methods

group_ :: QExpr be s a -> QGroupExpr be s a

General-purpose aggregate functions

sum_ :: (BeamSqlBackend be, Num a) => QExpr be s a -> QAgg be s (Maybe a)

SQL SUM(ALL ..) function (but without the explicit ALL)

avg_ :: (BeamSqlBackend be, Num a) => QExpr be s a -> QAgg be s (Maybe a)

SQL AVG(ALL ..) function (but without the explicit ALL)

min_ :: BeamSqlBackend be => QExpr be s a -> QAgg be s (Maybe a)

SQL MIN(ALL ..) function (but without the explicit ALL)

max_ :: BeamSqlBackend be => QExpr be s a -> QAgg be s (Maybe a)

SQL MAX(ALL ..) function (but without the explicit ALL)

count_ :: (BeamSqlBackend be, Integral b) => QExpr be s a -> QAgg be s b

SQL COUNT(ALL ..) function (but without the explicit ALL)

countAll_ :: (BeamSqlBackend be, Integral a) => QAgg be s a

SQL COUNT(*) function

rank_ :: (BeamSqlT611Backend be, Integral a) => QAgg be s a

SQL2003 RANK function (Requires T611 Elementary OLAP operations support)

cumeDist_ :: BeamSqlT612Backend be => QAgg be s Double

SQL2003 CUME_DIST function (Requires T612 Advanced OLAP operations support)

percentRank_ :: BeamSqlT612Backend be => QAgg be s Double

SQL2003 PERCENT_RANK function (Requires T612 Advanced OLAP operations support)

denseRank_ :: (BeamSqlT612Backend be, Integral a) => QAgg be s a

SQL2003 DENSE_RANK function (Requires T612 Advanced OLAP operations support)

rowNumber_ :: (BeamSql2003ExpressionBackend be, Integral a) => QAgg be s a

SQL2003 ROW_NUMBER function

every_ :: BeamSql99AggregationBackend be => QExpr be s SqlBool -> QAgg be s SqlBool

SQL99 EVERY(ALL ..) function (but without the explicit ALL)

any_ :: BeamSql99AggregationBackend be => QExpr be s SqlBool -> QAgg be s SqlBool

SQL99 ANY(ALL ..) function (but without the explicit ALL)

some_ :: BeamSql99AggregationBackend be => QExpr be s SqlBool -> QAgg be s SqlBool

SQL99 SOME(ALL ..) function (but without the explicit ALL)

Quantified aggregate functions

These functions correspond one-to-one with the <#gp-agg-funcs general-purpose aggregate functions>. However, they each take a mandatory "set quantifier", which is any of the set quantifier values.

sumOver_ :: (BeamSqlBackend be, Num a) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s (Maybe a)

avgOver_ :: (BeamSqlBackend be, Num a) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s (Maybe a)

minOver_ :: BeamSqlBackend be => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s (Maybe a)

maxOver_ :: BeamSqlBackend be => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s (Maybe a)

countOver_ :: (BeamSqlBackend be, Integral b) => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s a -> QAgg be s b

everyOver_ :: BeamSql99AggregationBackend be => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s SqlBool -> QAgg be s SqlBool

SQL EVERY, SOME, and ANY aggregates. Operates over SqlBool only, as the result can be NULL, even if all inputs are known (no input rows).

anyOver_ :: BeamSql99AggregationBackend be => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s SqlBool -> QAgg be s SqlBool

SQL EVERY, SOME, and ANY aggregates. Operates over SqlBool only, as the result can be NULL, even if all inputs are known (no input rows).

someOver_ :: BeamSql99AggregationBackend be => Maybe (BeamSqlBackendAggregationQuantifierSyntax be) -> QExpr be s SqlBool -> QAgg be s SqlBool

SQL EVERY, SOME, and ANY aggregates. Operates over SqlBool only, as the result can be NULL, even if all inputs are known (no input rows).

Set quantifiers

distinctInGroup_ :: IsSql92AggregationSetQuantifierSyntax s => Maybe s

Compute an aggregate only over distinct values in a group. Corresponds to the AGG(DISTINCT ..) syntax.

allInGroup_ :: IsSql92AggregationSetQuantifierSyntax s => Maybe s

Compute an aggregate over all values in a group. Corresponds semantically to the AGG(ALL ..) syntax, but doesn't produce an explicit ALL. To produce ALL expicitly, see allInGroupExplicitly_.

allInGroupExplicitly_ :: IsSql92AggregationSetQuantifierSyntax s => Maybe s

Compute an aggregate over all values in a group. Corresponds to the AGG(ALL ..) syntax. Note that ALL is the default for most aggregations, so you don't normally explicitly specify ALL. However, if you need to, you can use this function. To be explicit about quantification in the beam query DSL, but not produce an explicit ALL, use allInGroup_. allInGroup_ has the same semantic meaning, but does not produce an explicit ALL.

module Database.Beam.Query.CustomSQL

module Database.Beam.Query.DataTypes

SQL Command construction and execution

SELECT

newtype SqlSelect be a

Represents a select statement in the given backend, returning rows of type a.

Constructors

SqlSelect (BeamSqlBackendSelectSyntax be)

select :: forall be db res. (BeamSqlBackend be, HasQBuilder be, Projectible be res) => Q be db QBaseScope res -> SqlSelect be (QExprToIdentity res)

Build a SqlSelect for the given Q.

selectWith :: forall be db res. (BeamSqlBackend be, BeamSql99CommonTableExpressionBackend be, HasQBuilder be, Projectible be res) => With be db (Q be db QBaseScope res) -> SqlSelect be (QExprToIdentity res)

Create a SqlSelect for a query which may have common table expressions. See the documentation of With for more details.

lookup_ :: (Database be db, Table table, BeamSqlBackend be, HasQBuilder be, SqlValableTable be (PrimaryKey table), HasTableEquality be (PrimaryKey table)) => DatabaseEntity be db (TableEntity table) -> PrimaryKey table Identity -> SqlSelect be (table Identity)

Convenience function to generate a SqlSelect that looks up a table row given a primary key.

runSelectReturningList :: (MonadBeam be m, BeamSqlBackend be, FromBackendRow be a) => SqlSelect be a -> m [a]

Run a SqlSelect in a MonadBeam and get the results as a list

runSelectReturningOne :: (MonadBeam be m, BeamSqlBackend be, FromBackendRow be a) => SqlSelect be a -> m (Maybe a)

Run a SqlSelect in a MonadBeam and get the unique result, if there is one. Both no results as well as more than one result cause this to return Nothing.

runSelectReturningFirst :: (MonadBeam be m, BeamSqlBackend be, FromBackendRow be a) => SqlSelect be a -> m (Maybe a)

Run a SqlSelect in a MonadBeam and get the first result, if there is one. This is not guaranteed to automatically limit the query to one result.

dumpSqlSelect :: Projectible (MockSqlBackend SqlSyntaxBuilder) res => Q (MockSqlBackend SqlSyntaxBuilder) db QBaseScope res -> IO ()

Use a special debug syntax to print out an ANSI Standard SELECT statement that may be generated for a given Q.

INSERT

data SqlInsert be (table :: (Type -> Type) -> Type)

Represents a SQL INSERT command that has not yet been run

Constructors

SqlInsert !(TableSettings table) !(BeamSqlBackendInsertSyntax be)

SqlInsertNoRows

insert

Arguments

:: (BeamSqlBackend be, ProjectibleWithPredicate AnyType () Text (table (QField s)))

=> DatabaseEntity be db (TableEntity table)

Table to insert into

-> SqlInsertValues be (table (QExpr be s))

Values to insert. See insertValues, insertExpressions, and insertFrom for possibilities.

-> SqlInsert be table

Generate a SqlInsert given a table and a source of values.

insertOnly

Arguments

:: (BeamSqlBackend be, ProjectibleWithPredicate AnyType () Text (QExprToField r))

=> DatabaseEntity be db (TableEntity table)

Table to insert into

-> (table (QField s) -> QExprToField r)

-> SqlInsertValues be r

Values to insert. See insertValues, insertExpressions, insertData, and insertFrom for possibilities.

-> SqlInsert be table

Generate a SqlInsert over only certain fields of a table

runInsert :: (BeamSqlBackend be, MonadBeam be m) => SqlInsert be table -> m ()

Run a SqlInsert in a MonadBeam

data SqlInsertValues be proj

Represents a source of values that can be inserted into a table shaped like tbl.

Constructors

SqlInsertValues (BeamSqlBackendInsertValuesSyntax be)

SqlInsertValuesEmpty

insertExpressions :: forall be table s. (BeamSqlBackend be, Beamable table) => (forall s'. [table (QExpr be s')]) -> SqlInsertValues be (table (QExpr be s))

Build a SqlInsertValues from series of expressions in tables

insertValues :: forall be table s. (BeamSqlBackend be, Beamable table, FieldsFulfillConstraint (BeamSqlBackendCanSerialize be) table) => [table Identity] -> SqlInsertValues be (table (QExpr be s))

Build a SqlInsertValues from concrete table values

insertFrom :: (BeamSqlBackend be, HasQBuilder be, Projectible be r) => Q be db QBaseScope r -> SqlInsertValues be r

Build a SqlInsertValues from a SqlSelect that returns the same table

insertData :: forall be r. (Projectible be r, BeamSqlBackend be) => [r] -> SqlInsertValues be r

Build a SqlInsertValues from arbitrarily shaped data containing expressions

UPDATE

data SqlUpdate be (table :: (Type -> Type) -> Type)

Represents a SQL UPDATE statement for the given table.

Constructors

SqlUpdate !(TableSettings table) !(BeamSqlBackendUpdateSyntax be)

SqlIdentityUpdate

update

Arguments

:: (BeamSqlBackend be, Beamable table)

=> DatabaseEntity be db (TableEntity table)

The table to insert into

-> (forall s. table (QField s) -> QAssignment be s)

A sequence of assignments to make.

-> (forall s. table (QExpr be s) -> QExpr be s Bool)

Build a WHERE clause given a table containing expressions

-> SqlUpdate be table

Build a SqlUpdate given a table, a list of assignments, and a way to build a WHERE clause.

Use update' for comparisons with SqlBool.

See the (<-.) operator for ways to build assignments. The argument to the second argument is a the table parameterized over QField, which represents the left hand side of assignments. Sometimes, you'd like to also get the current value of a particular column. You can use the current_ function to convert a QField to a QGenExpr.

save

Arguments

:: forall table be db. (Table table, BeamSqlBackend be, SqlValableTable be (PrimaryKey table), SqlValableTable be table, HasTableEquality be (PrimaryKey table))

=> DatabaseEntity be db (TableEntity table)

Table to update

-> table Identity

Value to set to

-> SqlUpdate be table

Generate a SqlUpdate that will update the given table row with the given value.

The SQL UPDATE that is generated will set every non-primary key field for the row where each primary key field is exactly what is given.

Note: This is a pure SQL UPDATE command. This does not upsert or merge values.

Use save' for an internal SqlBool comparison.

update'

Arguments

:: (BeamSqlBackend be, Beamable table)

=> DatabaseEntity be db (TableEntity table)

The table to insert into

-> (forall s. table (QField s) -> QAssignment be s)

A sequence of assignments to make.

-> (forall s. table (QExpr be s) -> QExpr be s SqlBool)

Build a WHERE clause given a table containing expressions

-> SqlUpdate be table

Build a SqlUpdate given a table, a list of assignments, and a way to build a WHERE clause.

Uses a SqlBool comparison. Use update for comparisons with Bool.

See the (<-.) operator for ways to build assignments. The argument to the second argument is a the table parameterized over QField, which represents the left hand side of assignments. Sometimes, you'd like to also get the current value of a particular column. You can use the current_ function to convert a QField to a QGenExpr.

save'

Arguments

:: forall table be db. (Table table, BeamSqlBackend be, SqlValableTable be (PrimaryKey table), SqlValableTable be table, HasTableEquality be (PrimaryKey table))

=> DatabaseEntity be db (TableEntity table)

Table to update

-> table Identity

Value to set to

-> SqlUpdate be table

Generate a SqlUpdate that will update the given table row with the given value. This is a variant using update' and a SqlBool comparison.

The SQL UPDATE that is generated will set every non-primary key field for the row where each primary key field is exactly what is given.

Note: This is a pure SQL UPDATE command. This does not upsert or merge values.

Use save for an internal Bool comparison.

updateTable

Arguments

:: forall table db be. (BeamSqlBackend be, Beamable table)

=> DatabaseEntity be db (TableEntity table)

The table to update

-> table (QFieldAssignment be table)

Updates to be made (use set to construct an empty field)

-> (forall s. table (QExpr be s) -> QExpr be s Bool)

-> SqlUpdate be table

A specialization of update that is more convenient for normal tables.

Use updateTable' for comparisons with SqlBool.

updateTable'

Arguments

:: forall table db be. (BeamSqlBackend be, Beamable table)

=> DatabaseEntity be db (TableEntity table)

The table to update

-> table (QFieldAssignment be table)

Updates to be made (use set to construct an empty field)

-> (forall s. table (QExpr be s) -> QExpr be s SqlBool)

-> SqlUpdate be table

A specialization of update' that is more convenient for normal tables.

Use updateTable for comparisons with Bool.

set :: forall table be table'. Beamable table => table (QFieldAssignment be table')

setFieldsTo :: forall table be table'. Table table => (forall s. table (QExpr be s)) -> table (QFieldAssignment be table')

toNewValue :: (forall s. QExpr be s a) -> QFieldAssignment be table a

Use with set to set a field to an explicit new value that does not depend on any other value

toOldValue :: QFieldAssignment be table a

Use with set to not modify the field

toUpdatedValue :: (forall s. table (QExpr be s) -> QExpr be s a) -> QFieldAssignment be table a

Use with set to set a field to a new value that is calculated based on one or more fields from the existing row

toUpdatedValueMaybe :: (forall s. table (QExpr be s) -> Maybe (QExpr be s a)) -> QFieldAssignment be table a

Use with set to optionally set a fiield to a new value, calculated based on one or more fields from the existing row

updateRow

Arguments

:: (BeamSqlBackend be, Table table, HasTableEquality be (PrimaryKey table), SqlValableTable be (PrimaryKey table))

=> DatabaseEntity be db (TableEntity table)

The table to insert into

-> table Identity

The row to update

-> (forall s. table (QField s) -> QAssignment be s)

A sequence of assignments to make.

-> SqlUpdate be table

A specialization of update that matches the given (already existing) row.

Use updateRow' for an internal SqlBool comparison.

updateTableRow

Arguments

:: (BeamSqlBackend be, Table table, HasTableEquality be (PrimaryKey table), SqlValableTable be (PrimaryKey table))

=> DatabaseEntity be db (TableEntity table)

The table to update

-> table Identity

The row to update

-> table (QFieldAssignment be table)

Updates to be made (use set to construct an empty field)

-> SqlUpdate be table

Convenience form of updateTable that generates a WHERE clause that matches only the already existing entity.

Use updateTableRow' for an internal SqlBool comparison.

updateRow'

Arguments

:: (BeamSqlBackend be, Table table, HasTableEquality be (PrimaryKey table), SqlValableTable be (PrimaryKey table))

=> DatabaseEntity be db (TableEntity table)

The table to insert into

-> table Identity

The row to update

-> (forall s. table (QField s) -> QAssignment be s)

A sequence of assignments to make.

-> SqlUpdate be table

A specialization of update' that matches the given (already existing) row.

Use updateRow for an internal Bool comparison.

updateTableRow'

Arguments

:: (BeamSqlBackend be, Table table, HasTableEquality be (PrimaryKey table), SqlValableTable be (PrimaryKey table))

=> DatabaseEntity be db (TableEntity table)

The table to update

-> table Identity

The row to update

-> table (QFieldAssignment be table)

Updates to be made (use set to construct an empty field)

-> SqlUpdate be table

Convenience form of updateTable' that generates a WHERE clause that matches only the already existing entity.

Uses update' with a SqlBool comparison. Use updateTableRow for an internal Bool comparison.

runUpdate :: (BeamSqlBackend be, MonadBeam be m) => SqlUpdate be tbl -> m ()

Run a SqlUpdate in a MonadBeam.

DELETE

data SqlDelete be (table :: (Type -> Type) -> Type)

Represents a SQL DELETE statement for the given table

Constructors

SqlDelete !(TableSettings table) !(BeamSqlBackendDeleteSyntax be)

delete

Arguments

:: forall be db table. BeamSqlBackend be

=> DatabaseEntity be db (TableEntity table)

Table to delete from

-> (forall s. (forall s'. table (QExpr be s')) -> QExpr be s Bool)

Build a WHERE clause given a table containing expressions

-> SqlDelete be table

Build a SqlDelete from a table and a way to build a WHERE clause

runDelete :: (BeamSqlBackend be, MonadBeam be m) => SqlDelete be table -> m ()

Run a SqlDelete in a MonadBeam