Database.Beam.Query

Query type

type Projectible = ProjectibleWithPredicate AnyType

data Aggregation syntax s a

data QWindow syntax s

Instances

ProjectibleWithPredicate WindowFrameContext syntax (QWindow syntax s)

Defined in Database.Beam.Query.Internal

Methods

project' :: Monad m => Proxy WindowFrameContext -> (forall context. WindowFrameContext context => Proxy context -> WithExprContext syntax -> m (WithExprContext syntax)) -> QWindow syntax s -> m (QWindow syntax s)

type QWindowFrame = QGenExpr QWindowFrameContext

type QExpr = QGenExpr QValueContext

QExprs represent expressions not containing aggregates.

newtype QGenExpr context syntax 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 QExprs 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 -> syntax)

Instances

(Beamable t, contextPredicate context) => ProjectibleWithPredicate contextPredicate syntax (t (Nullable (QGenExpr context syntax s)))

Defined in Database.Beam.Query.Internal

Methods

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

(Beamable t, contextPredicate context) => ProjectibleWithPredicate contextPredicate syntax (t (QGenExpr context syntax s))

Defined in Database.Beam.Query.Internal

Methods

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

contextPredicate context => ProjectibleWithPredicate contextPredicate syntax (QGenExpr context syntax s a)

Defined in Database.Beam.Query.Internal

Methods

project' :: Monad m => Proxy contextPredicate -> (forall context0. contextPredicate context0 => Proxy context0 -> WithExprContext syntax -> m (WithExprContext syntax)) -> QGenExpr context syntax s a -> m (QGenExpr context syntax 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))

(IsSql92ExpressionSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) Bool, Beamable t) => SqlDeconstructMaybe syntax (t (Nullable (QGenExpr ctxt syntax s))) (t (QGenExpr ctxt syntax s)) s

Defined in Database.Beam.Query.Combinators

Methods

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

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

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

SqlOrderable syntax (QOrd syntax s a)

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: QOrd syntax s a -> [WithExprContext syntax]

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)

IsSql92ExpressionSyntax syntax => SqlDeconstructMaybe syntax (QGenExpr ctxt syntax s (Maybe x)) (QGenExpr ctxt syntax s x) s

Defined in Database.Beam.Query.Combinators

Methods

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

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

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

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 table, IsSql92ExpressionSyntax syntax, FieldsFulfillConstraintNullable (HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax)) table) => SqlValable (table (Nullable (QGenExpr ctxt syntax s)))

Defined in Database.Beam.Query.Combinators

Methods

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

(Beamable table, IsSql92ExpressionSyntax syntax, FieldsFulfillConstraint (HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax)) table) => SqlValable (table (QGenExpr ctxt syntax s))

Defined in Database.Beam.Query.Combinators

Methods

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

(Table t, IsSql92ExpressionSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) SqlNull) => SqlJustable (t (QExpr syntax s)) (t (Nullable (QExpr syntax s)))

Defined in Database.Beam.Query.Combinators

Methods

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

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

Beamable tbl => QGroupable (tbl (QExpr expr s)) (tbl (QGroupExpr expr 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 expr s) -> tbl (QGroupExpr expr s)

(Table t, IsSql92ExpressionSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) SqlNull) => SqlJustable (PrimaryKey t (QExpr syntax s)) (PrimaryKey t (Nullable (QExpr syntax s)))

Defined in Database.Beam.Query.Combinators

Methods

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

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

(IsSql92ExpressionSyntax syntax, FieldsFulfillConstraintNullable (HasSqlEqualityCheck syntax) tbl, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) Bool, Beamable tbl) => SqlEq (QGenExpr context syntax s) (tbl (Nullable (QGenExpr context syntax s)))

Defined in Database.Beam.Query.Ord

Methods

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

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

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

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

(IsSql92ExpressionSyntax syntax, FieldsFulfillConstraint (HasSqlEqualityCheck syntax) tbl, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) Bool, Beamable tbl) => SqlEq (QGenExpr context syntax s) (tbl (QGenExpr context syntax s))

Compare two arbitrary Beamable types containing QGenExprs for equality.

Defined in Database.Beam.Query.Ord

Methods

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

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

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

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

(IsSql92ExpressionSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) SqlNull) => SqlJustable (QExpr syntax s a) (QExpr syntax s (Maybe a))

Defined in Database.Beam.Query.Combinators

Methods

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

nothing_ :: QExpr syntax s (Maybe a)

QGroupable (QExpr expr s a) (QGroupExpr expr s a)

group_ for simple value expressions.

Defined in Database.Beam.Query.Aggregate

Methods

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

IsSql92ExpressionSyntax syntax => SqlOrdQuantified (QGenExpr context syntax s) (QQuantified syntax s a) (QGenExpr context syntax s a)

Defined in Database.Beam.Query.Ord

Methods

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

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

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

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

(IsSql92ExpressionSyntax syntax, HasSqlQuantifiedEqualityCheck syntax a) => SqlEqQuantified (QGenExpr context syntax s) (QQuantified syntax s a) (QGenExpr context syntax s a)

Two arbitrary expressions can be quantifiably compared for equality.

Defined in Database.Beam.Query.Ord

Methods

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

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

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

IsSql92ExpressionSyntax syntax => SqlOrd (QGenExpr context syntax s) (QGenExpr context syntax s a)

Defined in Database.Beam.Query.Ord

Methods

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

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

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

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

(IsSql92ExpressionSyntax syntax, HasSqlEqualityCheck syntax a) => SqlEq (QGenExpr context syntax s) (QGenExpr context syntax s a)

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

Defined in Database.Beam.Query.Ord

Methods

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

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

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

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

Eq syntax => Eq (QGenExpr context syntax s t)

Defined in Database.Beam.Query.Internal

Methods

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

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

(Fractional a, IsSql92ExpressionSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) a) => Fractional (QGenExpr context syntax s a)

Defined in Database.Beam.Query.Internal

Methods

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

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

fromRational :: Rational -> QGenExpr context syntax s a

(Num a, IsSql92ExpressionSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) a) => Num (QGenExpr context syntax s a)

Defined in Database.Beam.Query.Internal

Methods

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

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

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

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

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

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

fromInteger :: Integer -> QGenExpr context syntax s a

(IsSql92ExpressionSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) [Char]) => IsString (QGenExpr context syntax s Text)

Defined in Database.Beam.Query.Internal

Methods

fromString :: String -> QGenExpr context syntax s Text

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

(HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) a, IsSql92ExpressionSyntax syntax) => SqlValable (QGenExpr ctxt syntax s a)

Defined in Database.Beam.Query.Combinators

Methods

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

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 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 HaskellLiteralForQExpr (table (QGenExpr context syntax s))

Defined in Database.Beam.Query.Combinators

type HaskellLiteralForQExpr (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 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 HaskellLiteralForQExpr (QGenExpr context syntax s a)

Defined in Database.Beam.Query.Combinators

type HaskellLiteralForQExpr (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

data Q syntax (db :: (* -> *) -> *) 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 QExprs. syntax represents the SQL syntax that this query is building.

Instances

Monad (Q syntax db s)

Defined in Database.Beam.Query.Internal

Methods

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

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

return :: a -> Q syntax db s a

fail :: String -> Q syntax db s a

Functor (Q syntax db s)

Defined in Database.Beam.Query.Internal

Methods

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

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

Applicative (Q syntax db s)

Defined in Database.Beam.Query.Internal

Methods

pure :: a -> Q syntax db s a

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

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

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

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

class IsSql92SelectSyntax selectSyntax => HasQBuilder selectSyntax where

Minimal complete definition

buildSqlQuery

Methods

buildSqlQuery :: Projectible (Sql92SelectExpressionSyntax selectSyntax) a => TablePrefix -> Q selectSyntax db s a -> selectSyntax

Instances

HasQBuilder Select

Defined in Database.Beam.Query.Types

Methods

buildSqlQuery :: Projectible (Sql92SelectExpressionSyntax Select) a => TablePrefix -> Q Select db s a -> Select

HasQBuilder SqlSyntaxBuilder

Defined in Database.Beam.Query.Types

Methods

buildSqlQuery :: Projectible (Sql92SelectExpressionSyntax SqlSyntaxBuilder) a => TablePrefix -> Q SqlSyntaxBuilder db s a -> SqlSyntaxBuilder

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 (a, b)

Defined in Database.Beam.Query.Types

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

type QExprToField (Vector n a)

Defined in Database.Beam.Query.Types

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

type QExprToField (a, b, c)

Defined in Database.Beam.Query.Types

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

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

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 (a, b)

Defined in Database.Beam.Query.Types

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

type QExprToIdentity (Vector n a)

Defined in Database.Beam.Query.Types

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

type QExprToIdentity (a, b, c)

Defined in Database.Beam.Query.Types

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

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

Query expression contexts

A context is a type-level value that signifies where an expression can be used. For example, QExpr corresponds to QGenExprs that result in values. In reality, QExpr 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 (QExpr expr s)) (tbl (QGroupExpr expr 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 expr s) -> tbl (QGroupExpr expr s)

QGroupable (QExpr expr s a) (QGroupExpr expr s a)

group_ for simple value expressions.

Defined in Database.Beam.Query.Aggregate

Methods

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

type ContextName QGroupingContext

Defined in Database.Beam.Query.Internal

type ContextName QGroupingContext = "an aggregate grouping"

data QValueContext

Instances

(Table t, IsSql92ExpressionSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) SqlNull) => SqlJustable (t (QExpr syntax s)) (t (Nullable (QExpr syntax s)))

Defined in Database.Beam.Query.Combinators

Methods

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

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

Beamable tbl => QGroupable (tbl (QExpr expr s)) (tbl (QGroupExpr expr 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 expr s) -> tbl (QGroupExpr expr s)

(Table t, IsSql92ExpressionSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) SqlNull) => SqlJustable (PrimaryKey t (QExpr syntax s)) (PrimaryKey t (Nullable (QExpr syntax s)))

Defined in Database.Beam.Query.Combinators

Methods

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

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

(IsSql92ExpressionSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) SqlNull) => SqlJustable (QExpr syntax s a) (QExpr syntax s (Maybe a))

Defined in Database.Beam.Query.Combinators

Methods

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

nothing_ :: QExpr syntax s (Maybe a)

QGroupable (QExpr expr s a) (QGroupExpr expr s a)

group_ for simple value expressions.

Defined in Database.Beam.Query.Aggregate

Methods

group_ :: QExpr expr s a -> QGroupExpr expr s 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 QueryableSqlSyntax cmd = (IsSql92Syntax cmd, Sql92SanityCheck cmd, HasQBuilder (Sql92SelectSyntax cmd))

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

A version of the table where each field is a QGenExpr

type QExprTable syntax s tbl = QGenExprTable QValueContext syntax s tbl

Various SQL functions and constructs

coalesce_ :: IsSql92ExpressionSyntax expr => [QGenExpr ctxt expr s (Maybe a)] -> QGenExpr ctxt expr s a -> QGenExpr ctxt expr s a

SQL COALESCE support

fromMaybe_ :: IsSql92ExpressionSyntax expr => QGenExpr ctxt expr s a -> QGenExpr ctxt expr s (Maybe a) -> QGenExpr ctxt expr s a

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

position_ :: (IsSqlExpressionSyntaxStringType syntax text, IsSql92ExpressionSyntax syntax, Integral b) => QExpr syntax s text -> QExpr syntax s text -> QExpr syntax s b

SQL POSITION(.. IN ..) function

charLength_ :: (IsSqlExpressionSyntaxStringType syntax text, IsSql92ExpressionSyntax syntax) => QGenExpr context syntax s text -> QGenExpr context syntax s Int

SQL CHAR_LENGTH function

octetLength_ :: (IsSqlExpressionSyntaxStringType syntax text, IsSql92ExpressionSyntax syntax) => QGenExpr context syntax s text -> QGenExpr context syntax s Int

SQL OCTET_LENGTH function

bitLength_ :: IsSql92ExpressionSyntax syntax => QGenExpr context syntax s SqlBitString -> QGenExpr context syntax s Int

SQL BIT_LENGTH function

currentTimestamp_ :: IsSql92ExpressionSyntax syntax => QGenExpr ctxt syntax s LocalTime

SQL CURRENT_TIMESTAMP function

lower_ :: (IsSqlExpressionSyntaxStringType syntax text, IsSql92ExpressionSyntax syntax) => QGenExpr context syntax s text -> QGenExpr context syntax s text

SQL LOWER function

upper_ :: (IsSqlExpressionSyntaxStringType syntax text, IsSql92ExpressionSyntax syntax) => QGenExpr context syntax s text -> QGenExpr context syntax s text

SQL UPPER function

trim_ :: (IsSqlExpressionSyntaxStringType syntax text, IsSql92ExpressionSyntax syntax) => QGenExpr context syntax s text -> QGenExpr context syntax s text

SQL TRIM function

IF-THEN-ELSE support

if_ :: IsSql92ExpressionSyntax expr => [QIfCond context expr s a] -> QIfElse context expr s a -> QGenExpr context expr s a

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

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

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

SQL UPDATE assignments

(<-.) :: forall fieldName. (SqlUpdatable expr s lhs rhs, IsSql92FieldNameSyntax fieldName) => lhs -> rhs -> QAssignment fieldName expr s infix 4

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

current_ :: IsSql92ExpressionSyntax expr => QField s ty -> QExpr expr 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 (QGenExpr context syntax s))

Defined in Database.Beam.Query.Combinators

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

type HaskellLiteralForQExpr (table (Nullable f))

Defined in Database.Beam.Query.Combinators

type HaskellLiteralForQExpr (table (Nullable f))

type HaskellLiteralForQExpr (QGenExpr context syntax s a)

Defined in Database.Beam.Query.Combinators

type HaskellLiteralForQExpr (QGenExpr context syntax s a) = a

class SqlValable a where

Minimal complete definition

val_

Methods

val_ :: HaskellLiteralForQExpr a -> a

Instances

(Beamable table, IsSql92ExpressionSyntax syntax, FieldsFulfillConstraintNullable (HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax)) table) => SqlValable (table (Nullable (QGenExpr ctxt syntax s)))

Defined in Database.Beam.Query.Combinators

Methods

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

(Beamable table, IsSql92ExpressionSyntax syntax, FieldsFulfillConstraint (HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax)) table) => SqlValable (table (QGenExpr ctxt syntax s))

Defined in Database.Beam.Query.Combinators

Methods

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

(HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) a, IsSql92ExpressionSyntax syntax) => SqlValable (QGenExpr ctxt syntax s a)

Defined in Database.Beam.Query.Combinators

Methods

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

type SqlValableTable table expr = (Beamable table, IsSql92ExpressionSyntax expr, FieldsFulfillConstraint (HasSqlValueSyntax (Sql92ExpressionValueSyntax expr)) table)

default_ :: IsSql92ExpressionSyntax expr => QGenExpr ctxt expr s a

General query combinators

all_ :: forall be (db :: (* -> *) -> *) table select s. (Database be db, IsSql92SelectSyntax select, IsSql92FromSyntax (Sql92SelectTableFromSyntax (Sql92SelectSelectTableSyntax select)), IsSql92TableSourceSyntax (Sql92FromTableSourceSyntax (Sql92SelectTableFromSyntax (Sql92SelectSelectTableSyntax select))), Sql92FromExpressionSyntax (Sql92SelectTableFromSyntax (Sql92SelectSelectTableSyntax select)) ~ Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select), Table table) => DatabaseEntity be db (TableEntity table) -> Q select db s (table (QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s))

Introduce all entries of a table into the Q monad

allFromView_ :: forall be (db :: (* -> *) -> *) table select s. (Database be db, IsSql92SelectSyntax select, IsSql92FromSyntax (Sql92SelectTableFromSyntax (Sql92SelectSelectTableSyntax select)), IsSql92TableSourceSyntax (Sql92FromTableSourceSyntax (Sql92SelectTableFromSyntax (Sql92SelectSelectTableSyntax select))), Sql92FromExpressionSyntax (Sql92SelectTableFromSyntax (Sql92SelectSelectTableSyntax select)) ~ Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select), Beamable table) => DatabaseEntity be db (ViewEntity table) -> Q select db s (table (QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s))

Introduce all entries of a view into the Q monad

join_ :: (Database be db, Table table, IsSql92SelectSyntax select, IsSql92FromSyntax (Sql92SelectTableFromSyntax (Sql92SelectSelectTableSyntax select)), Sql92FromExpressionSyntax (Sql92SelectTableFromSyntax (Sql92SelectSelectTableSyntax select)) ~ Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select), IsSql92TableSourceSyntax (Sql92FromTableSourceSyntax (Sql92SelectTableFromSyntax (Sql92SelectSelectTableSyntax select)))) => DatabaseEntity be db (TableEntity table) -> (table (QExpr (Sql92SelectExpressionSyntax select) s) -> QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s Bool) -> Q select db s (table (QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) 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, IsSql92SelectSyntax select, IsSql92FromSyntax (Sql92SelectTableFromSyntax (Sql92SelectSelectTableSyntax select)), Sql92FromExpressionSyntax (Sql92SelectTableFromSyntax (Sql92SelectSelectTableSyntax select)) ~ Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select), IsSql92TableSourceSyntax (Sql92FromTableSourceSyntax (Sql92SelectTableFromSyntax (Sql92SelectSelectTableSyntax select)))) => DatabaseEntity be db (TableEntity table) -> (table (QExpr (Sql92SelectExpressionSyntax select) s) -> QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s SqlBool) -> Q select db s (table (QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s))

Like join_, but accepting an ON condition that returns SqlBool

guard_ :: forall select db s. IsSql92SelectSyntax select => QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s Bool -> Q select db s ()

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

guard_' :: forall select db s. IsSql92SelectSyntax select => QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s SqlBool -> Q select db s ()

Only allow results for which the QExpr 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 select db s. IsSql92SelectSyntax select => (r -> QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s Bool) -> Q select db s r -> Q select db s r

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

filter_' :: forall r select db s. IsSql92SelectSyntax select => (r -> QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s SqlBool) -> Q select db s r -> Q select db s r

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

related_ :: forall be db rel select s. (IsSql92SelectSyntax select, HasTableEquality (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) (PrimaryKey rel), HasSqlValueSyntax (Sql92ExpressionValueSyntax (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select))) Bool, Database be db, Table rel) => DatabaseEntity be db (TableEntity rel) -> PrimaryKey rel (QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s) -> Q select db s (rel (QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s))

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

relatedBy_ :: forall be db rel select s. (Database be db, Table rel, HasSqlValueSyntax (Sql92ExpressionValueSyntax (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select))) Bool, IsSql92SelectSyntax select) => DatabaseEntity be db (TableEntity rel) -> (rel (QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s) -> QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s Bool) -> Q select db s (rel (QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s))

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

relatedBy_' :: forall be db rel select s. (Database be db, Table rel, HasSqlValueSyntax (Sql92ExpressionValueSyntax (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select))) Bool, IsSql92SelectSyntax select) => DatabaseEntity be db (TableEntity rel) -> (rel (QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s) -> QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s SqlBool) -> Q select db s (rel (QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s))

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

leftJoin_ :: forall s r select db. (Projectible (Sql92SelectExpressionSyntax select) r, IsSql92SelectSyntax select, ThreadRewritable (QNested s) r, Retaggable (QExpr (Sql92SelectExpressionSyntax select) s) (WithRewrittenThread (QNested s) s r)) => Q select db (QNested s) r -> (WithRewrittenThread (QNested s) s r -> QExpr (Sql92SelectExpressionSyntax select) s Bool) -> Q select 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 select db. (Projectible (Sql92SelectExpressionSyntax select) r, IsSql92SelectSyntax select, ThreadRewritable (QNested s) r, Retaggable (QExpr (Sql92SelectExpressionSyntax select) s) (WithRewrittenThread (QNested s) s r)) => Q select db (QNested s) r -> (WithRewrittenThread (QNested s) s r -> QExpr (Sql92SelectExpressionSyntax select) s SqlBool) -> Q select db s (Retag Nullable (WithRewrittenThread (QNested s) s r))

Like leftJoin_, but accepts an ON clause returning SqlBool.

perhaps_ :: forall s r select db. (Projectible (Sql92SelectExpressionSyntax select) r, IsSql92SelectSyntax select, ThreadRewritable (QNested s) r, Retaggable (QExpr (Sql92SelectExpressionSyntax select) s) (WithRewrittenThread (QNested s) s r)) => Q select db (QNested s) r -> Q select 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 select db. (Projectible (Sql92SelectExpressionSyntax select) a, Projectible (Sql92SelectExpressionSyntax select) b, ThreadRewritable (QNested s) a, ThreadRewritable (QNested s) b, Retaggable (QExpr (Sql92SelectExpressionSyntax select) s) (WithRewrittenThread (QNested s) s a), Retaggable (QExpr (Sql92SelectExpressionSyntax select) s) (WithRewrittenThread (QNested s) s b), IsSql92FromOuterJoinSyntax (Sql92SelectFromSyntax select)) => Q select db (QNested s) a -> Q select db (QNested s) b -> ((WithRewrittenThread (QNested s) s a, WithRewrittenThread (QNested s) s b) -> QExpr (Sql92SelectExpressionSyntax select) s Bool) -> Q select 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 select db. (Projectible (Sql92SelectExpressionSyntax select) a, Projectible (Sql92SelectExpressionSyntax select) b, ThreadRewritable (QNested s) a, ThreadRewritable (QNested s) b, Retaggable (QExpr (Sql92SelectExpressionSyntax select) s) (WithRewrittenThread (QNested s) s a), Retaggable (QExpr (Sql92SelectExpressionSyntax select) s) (WithRewrittenThread (QNested s) s b), IsSql92FromOuterJoinSyntax (Sql92SelectFromSyntax select)) => Q select db (QNested s) a -> Q select db (QNested s) b -> ((WithRewrittenThread (QNested s) s a, WithRewrittenThread (QNested s) s b) -> QExpr (Sql92SelectExpressionSyntax select) s SqlBool) -> Q select 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 select db. (ThreadRewritable (QNested s) r, ProjectibleInSelectSyntax select r) => Q select db (QNested s) r -> Q select db s (WithRewrittenThread (QNested s) s r)

references_ :: (IsSql92ExpressionSyntax expr, HasTableEquality expr (PrimaryKey t), HasSqlValueSyntax (Sql92ExpressionValueSyntax expr) Bool, Table t) => PrimaryKey t (QGenExpr ctxt expr s) -> t (QGenExpr ctxt expr s) -> QGenExpr ctxt expr s Bool

Generate an appropriate boolean QGenExpr comparing the given foreign key to the given table. Useful for creating join conditions.

nub_ :: (IsSql92SelectSyntax select, Projectible (Sql92SelectExpressionSyntax select) r) => Q select db s r -> Q select 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)'

Minimal complete definition

just_, nothing_

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, IsSql92ExpressionSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) SqlNull) => SqlJustable (t (QExpr syntax s)) (t (Nullable (QExpr syntax s)))

Defined in Database.Beam.Query.Combinators

Methods

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

nothing_ :: t (Nullable (QExpr syntax 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, IsSql92ExpressionSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) SqlNull) => SqlJustable (PrimaryKey t (QExpr syntax s)) (PrimaryKey t (Nullable (QExpr syntax s)))

Defined in Database.Beam.Query.Combinators

Methods

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

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

(IsSql92ExpressionSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) SqlNull) => SqlJustable (QExpr syntax s a) (QExpr syntax s (Maybe a))

Defined in Database.Beam.Query.Combinators

Methods

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

nothing_ :: QExpr syntax s (Maybe a)

class IsSql92ExpressionSyntax syntax => SqlDeconstructMaybe syntax a nonNullA s | a s -> syntax, 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'.

Minimal complete definition

isJust_, isNothing_, maybe_

Methods

isJust_ :: a -> QGenExpr ctxt syntax s Bool

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

isNothing_ :: a -> QGenExpr ctxt syntax s Bool

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

maybe_ :: QGenExpr ctxt syntax s y -> (nonNullA -> QGenExpr ctxt syntax s y) -> a -> QGenExpr ctxt syntax 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

(IsSql92ExpressionSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) Bool, Beamable t) => SqlDeconstructMaybe syntax (t (Nullable (QGenExpr ctxt syntax s))) (t (QGenExpr ctxt syntax s)) s

Defined in Database.Beam.Query.Combinators

Methods

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

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

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

IsSql92ExpressionSyntax syntax => SqlDeconstructMaybe syntax (QGenExpr ctxt syntax s (Maybe x)) (QGenExpr ctxt syntax s x) s

Defined in Database.Beam.Query.Combinators

Methods

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

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

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

class SqlOrderable syntax a | a -> syntax

Minimal complete definition

makeSQLOrdering

Instances

SqlOrderable syntax a => SqlOrderable syntax [a]

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: [a] -> [WithExprContext syntax]

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

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: (a, b) -> [WithExprContext syntax]

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

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: (a, b, c) -> [WithExprContext syntax]

SqlOrderable syntax (QOrd syntax s a)

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: QOrd syntax s a -> [WithExprContext syntax]

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

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: (a, b, c, d) -> [WithExprContext syntax]

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

Defined in Database.Beam.Query.Combinators

Methods

makeSQLOrdering :: (a, b, c, d, e) -> [WithExprContext syntax]

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

Defined in Database.Beam.Query.Combinators

Methods

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

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

Defined in Database.Beam.Query.Combinators

Methods

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

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

Defined in Database.Beam.Query.Combinators

Methods

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

data QIfCond context expr s a

data QIfElse context expr s a

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

Limit the number of results returned by a query.

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

Drop the first offset' results.

as_ :: forall a ctxt syntax s. QGenExpr ctxt syntax s a -> QGenExpr ctxt syntax 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_ @Int countAll_) ..

Subqueries

exists_ :: (IsSql92SelectSyntax select, HasQBuilder select, ProjectibleInSelectSyntax select a, Sql92ExpressionSelectSyntax (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) ~ select) => Q select db s a -> QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s Bool

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

unique_ :: (IsSql92SelectSyntax select, HasQBuilder select, ProjectibleInSelectSyntax select a, Sql92ExpressionSelectSyntax (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) ~ select) => Q select db s a -> QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s Bool

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

distinct_ :: (IsSql99ExpressionSyntax (Sql92SelectExpressionSyntax select), HasQBuilder select, ProjectibleInSelectSyntax select a, Sql92ExpressionSelectSyntax (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) ~ select) => Q select db s a -> QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s Bool

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

subquery_ :: (IsSql92SelectSyntax select, HasQBuilder select, ProjectibleInSelectSyntax select (QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s a), Sql92ExpressionSelectSyntax (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) ~ select) => Q select (db :: (* -> *) -> *) s (QExpr (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) s a) -> QGenExpr ctxt (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) 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 select db s a. (IsSql92SelectSyntax select, Projectible (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) a, ProjectibleInSelectSyntax select a, ThreadRewritable (QNested s) a) => Q select db (QNested s) a -> Q select db (QNested s) a -> Q select db s (WithRewrittenThread (QNested s) s a)

SQL UNION operator

unionAll_ :: forall select db s a. (IsSql92SelectSyntax select, Projectible (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) a, ProjectibleInSelectSyntax select a, ThreadRewritable (QNested s) a) => Q select db (QNested s) a -> Q select db (QNested s) a -> Q select db s (WithRewrittenThread (QNested s) s a)

SQL UNION ALL operator

intersect_ :: forall select db s a. (IsSql92SelectSyntax select, Projectible (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) a, ProjectibleInSelectSyntax select a, ThreadRewritable (QNested s) a) => Q select db (QNested s) a -> Q select db (QNested s) a -> Q select db s (WithRewrittenThread (QNested s) s a)

SQL INTERSECT operator

intersectAll_ :: forall select db s a. (IsSql92SelectSyntax select, Projectible (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) a, ProjectibleInSelectSyntax select a, ThreadRewritable (QNested s) a) => Q select db (QNested s) a -> Q select db (QNested s) a -> Q select db s (WithRewrittenThread (QNested s) s a)

SQL INTERSECT ALL operator

except_ :: forall select db s a. (IsSql92SelectSyntax select, Projectible (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) a, ProjectibleInSelectSyntax select a, ThreadRewritable (QNested s) a) => Q select db (QNested s) a -> Q select db (QNested s) a -> Q select db s (WithRewrittenThread (QNested s) s a)

SQL EXCEPT operator

exceptAll_ :: forall select db s a. (IsSql92SelectSyntax select, Projectible (Sql92SelectTableExpressionSyntax (Sql92SelectSelectTableSyntax select)) a, ProjectibleInSelectSyntax select a, ThreadRewritable (QNested s) a) => Q select db (QNested s) a -> Q select db (QNested s) a -> Q select db s (WithRewrittenThread (QNested s) s a)

SQL EXCEPT ALL operator

Window functions

See the corresponding manual section for more.

over_ :: IsSql2003ExpressionSyntax syntax => QAgg syntax s a -> QWindow (Sql2003ExpressionWindowFrameSyntax syntax) s -> QWindowExpr syntax s a

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

frame_

Arguments

:: (IsSql2003ExpressionSyntax syntax, SqlOrderable (Sql2003WindowFrameOrderingSyntax (Sql2003ExpressionWindowFrameSyntax syntax)) ordering, Projectible syntax partition, Sql2003ExpressionSanityCheck syntax)

=> Maybe partition

PARTITION BY

-> Maybe ordering

ORDER BY

-> QFrameBounds (Sql2003WindowFrameBoundsSyntax (Sql2003ExpressionWindowFrameSyntax syntax))

RANGE / ROWS

-> QWindow (Sql2003ExpressionWindowFrameSyntax syntax) s

Specify a window frame with all the options

bounds_ :: IsSql2003WindowFrameBoundsSyntax syntax => QFrameBound (Sql2003WindowFrameBoundsBoundSyntax syntax) -> Maybe (QFrameBound (Sql2003WindowFrameBoundsBoundSyntax syntax)) -> QFrameBounds syntax

unbounded_ :: IsSql2003WindowFrameBoundSyntax syntax => QFrameBound syntax

nrows_ :: IsSql2003WindowFrameBoundSyntax syntax => Int -> QFrameBound syntax

fromBound_ :: IsSql2003WindowFrameBoundsSyntax syntax => QFrameBound (Sql2003WindowFrameBoundsBoundSyntax syntax) -> QFrameBounds syntax

noBounds_ :: QFrameBounds syntax

noOrder_ :: Maybe (QOrd syntax s Int)

noPartition_ :: Maybe (QOrd syntax s Int)

partitionBy_ :: partition -> Maybe partition

orderPartitionBy_ :: partition -> Maybe partition

withWindow_

Arguments

:: (ProjectibleWithPredicate WindowFrameContext (Sql2003ExpressionWindowFrameSyntax (Sql92SelectExpressionSyntax select)) window, Projectible (Sql92SelectExpressionSyntax select) r, Projectible (Sql92SelectExpressionSyntax select) a, ContextRewritable a, ThreadRewritable (QNested s) (WithRewrittenContext a QValueContext), IsSql92SelectSyntax select)

=> (r -> window)

Window builder function

-> (r -> window -> a)

Projection builder function. Has access to the windows generated above

-> Q select db (QNested s) r

Query to window over

-> Q select 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 syntax db. (Projectible (Sql92SelectExpressionSyntax syntax) a, SqlOrderable (Sql92SelectOrderingSyntax syntax) ordering, ThreadRewritable (QNested s) a) => (a -> ordering) -> Q syntax db (QNested s) a -> Q syntax 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 syntax s a. IsSql92OrderingSyntax syntax => QExpr (Sql92OrderingExpressionSyntax syntax) s a -> QOrd syntax s a

Produce a QOrd corresponding to a SQL ASC ordering

desc_ :: forall syntax s a. IsSql92OrderingSyntax syntax => QExpr (Sql92OrderingExpressionSyntax syntax) s a -> QOrd syntax s a

Produce a QOrd corresponding to a SQL DESC ordering

nullsFirst_ :: IsSql2003OrderingElementaryOLAPOperationsSyntax syntax => QOrd syntax s a -> QOrd syntax s a

nullsLast_ :: IsSql2003OrderingElementaryOLAPOperationsSyntax syntax => QOrd syntax s a -> QOrd syntax s a

Various combinators corresponding to SQL extensions

T614 NTILE function

ntile_ :: (Integral a, IsSql2003NtileExpressionSyntax syntax) => QExpr syntax s Int -> QAgg syntax s a

T615 LEAD and LAG function

lead1_ :: IsSql2003LeadAndLagExpressionSyntax syntax => QExpr syntax s a -> QAgg syntax s a

lag1_ :: IsSql2003LeadAndLagExpressionSyntax syntax => QExpr syntax s a -> QAgg syntax s a

lead_ :: IsSql2003LeadAndLagExpressionSyntax syntax => QExpr syntax s a -> QExpr syntax s Int -> QAgg syntax s a

lag_ :: IsSql2003LeadAndLagExpressionSyntax syntax => QExpr syntax s a -> QExpr syntax s Int -> QAgg syntax s a

leadWithDefault_ :: IsSql2003LeadAndLagExpressionSyntax syntax => QExpr syntax s a -> QExpr syntax s Int -> QExpr syntax s a -> QAgg syntax s a

lagWithDefault_ :: IsSql2003LeadAndLagExpressionSyntax syntax => QExpr syntax s a -> QExpr syntax s Int -> QExpr syntax s a -> QAgg syntax s a

T616 FIRST_VALUE and LAST_VALUE functions

firstValue_ :: IsSql2003FirstValueAndLastValueExpressionSyntax syntax => QExpr syntax s a -> QAgg syntax s a

lastValue_ :: IsSql2003FirstValueAndLastValueExpressionSyntax syntax => QExpr syntax s a -> QAgg syntax s a

T618 NTH_VALUE function

nthValue_ :: IsSql2003NthValueExpressionSyntax syntax => QExpr syntax s a -> QExpr syntax s Int -> QAgg syntax s a

T621 Enhanced numeric functions

(**.) :: (Floating a, IsSql2003EnhancedNumericFunctionsExpressionSyntax syntax) => QGenExpr ctxt syntax s a -> QGenExpr ctxt syntax s a -> QGenExpr ctxt syntax s a infixr 8

ln_ :: (Floating a, IsSql2003EnhancedNumericFunctionsExpressionSyntax syntax) => QGenExpr ctxt syntax s a -> QGenExpr ctxt syntax s a

exp_ :: (Floating a, IsSql2003EnhancedNumericFunctionsExpressionSyntax syntax) => QGenExpr ctxt syntax s a -> QGenExpr ctxt syntax s a

sqrt_ :: (Floating a, IsSql2003EnhancedNumericFunctionsExpressionSyntax syntax) => QGenExpr ctxt syntax s a -> QGenExpr ctxt syntax s a

ceiling_ :: (RealFrac a, Integral b, IsSql2003EnhancedNumericFunctionsExpressionSyntax syntax) => QGenExpr ctxt syntax s a -> QGenExpr ctxt syntax s b

floor_ :: (RealFrac a, Integral b, IsSql2003EnhancedNumericFunctionsExpressionSyntax syntax) => QGenExpr ctxt syntax s a -> QGenExpr ctxt syntax s b

stddevPopOver_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => Maybe (Sql92AggregationSetQuantifierSyntax syntax) -> QExpr syntax s a -> QAgg syntax s b

stddevSampOver_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => Maybe (Sql92AggregationSetQuantifierSyntax syntax) -> QExpr syntax s a -> QAgg syntax s b

varPopOver_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => Maybe (Sql92AggregationSetQuantifierSyntax syntax) -> QExpr syntax s a -> QAgg syntax s b

varSampOver_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => Maybe (Sql92AggregationSetQuantifierSyntax syntax) -> QExpr syntax s a -> QAgg syntax s b

stddevPop_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => QExpr syntax s a -> QAgg syntax s b

stddevSamp_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => QExpr syntax s a -> QAgg syntax s b

varPop_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => QExpr syntax s a -> QAgg syntax s b

varSamp_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => QExpr syntax s a -> QAgg syntax s b

covarPopOver_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => Maybe (Sql92AggregationSetQuantifierSyntax syntax) -> QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

covarSampOver_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => Maybe (Sql92AggregationSetQuantifierSyntax syntax) -> QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

corrOver_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => Maybe (Sql92AggregationSetQuantifierSyntax syntax) -> QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrSlopeOver_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => Maybe (Sql92AggregationSetQuantifierSyntax syntax) -> QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrInterceptOver_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => Maybe (Sql92AggregationSetQuantifierSyntax syntax) -> QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrCountOver_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => Maybe (Sql92AggregationSetQuantifierSyntax syntax) -> QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrRSquaredOver_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => Maybe (Sql92AggregationSetQuantifierSyntax syntax) -> QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrAvgXOver_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => Maybe (Sql92AggregationSetQuantifierSyntax syntax) -> QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrAvgYOver_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => Maybe (Sql92AggregationSetQuantifierSyntax syntax) -> QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrSXXOver_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => Maybe (Sql92AggregationSetQuantifierSyntax syntax) -> QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrSYYOver_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => Maybe (Sql92AggregationSetQuantifierSyntax syntax) -> QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrSXYOver_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => Maybe (Sql92AggregationSetQuantifierSyntax syntax) -> QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

covarPop_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

covarSamp_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

corr_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrSlope_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrIntercept_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrCount_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrRSquared_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrAvgX_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrAvgY_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrSXX_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrSYY_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

regrSXY_ :: (Num a, Floating b, IsSql2003EnhancedNumericFunctionsAggregationExpressionSyntax syntax) => QExpr syntax s a -> QExpr syntax s a -> QExpr syntax s b

Relationships

Many-to-many relationships

type ManyToMany db left right = forall syntax s. (Sql92SelectSanityCheck syntax, IsSql92SelectSyntax syntax, SqlEq (QExpr (Sql92SelectExpressionSyntax syntax) s) (PrimaryKey left (QExpr (Sql92SelectExpressionSyntax syntax) s)), SqlEq (QExpr (Sql92SelectExpressionSyntax syntax) s) (PrimaryKey right (QExpr (Sql92SelectExpressionSyntax syntax) s))) => Q syntax db s (left (QExpr (Sql92SelectExpressionSyntax syntax) s)) -> Q syntax db s (right (QExpr (Sql92SelectExpressionSyntax syntax) s)) -> Q syntax db s (left (QExpr (Sql92SelectExpressionSyntax syntax) s), right (QExpr (Sql92SelectExpressionSyntax syntax) s))

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

type ManyToManyThrough db through left right = forall syntax s. (Sql92SelectSanityCheck syntax, IsSql92SelectSyntax syntax, SqlEq (QExpr (Sql92SelectExpressionSyntax syntax) s) (PrimaryKey left (QExpr (Sql92SelectExpressionSyntax syntax) s)), SqlEq (QExpr (Sql92SelectExpressionSyntax syntax) s) (PrimaryKey right (QExpr (Sql92SelectExpressionSyntax syntax) s))) => Q syntax db s (left (QExpr (Sql92SelectExpressionSyntax syntax) s)) -> Q syntax db s (right (QExpr (Sql92SelectExpressionSyntax syntax) s)) -> Q syntax db s (through (QExpr (Sql92SelectExpressionSyntax syntax) s), left (QExpr (Sql92SelectExpressionSyntax syntax) s), right (QExpr (Sql92SelectExpressionSyntax syntax) 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, Sql92SelectSanityCheck syntax, IsSql92SelectSyntax syntax, SqlEq (QExpr (Sql92SelectExpressionSyntax syntax) s) (PrimaryKey left (QExpr (Sql92SelectExpressionSyntax syntax) s)), SqlEq (QExpr (Sql92SelectExpressionSyntax syntax) s) (PrimaryKey right (QExpr (Sql92SelectExpressionSyntax syntax) s))) => DatabaseEntity be db (TableEntity joinThrough) -> (joinThrough (QExpr (Sql92SelectExpressionSyntax syntax) s) -> PrimaryKey left (QExpr (Sql92SelectExpressionSyntax syntax) s)) -> (joinThrough (QExpr (Sql92SelectExpressionSyntax syntax) s) -> PrimaryKey right (QExpr (Sql92SelectExpressionSyntax syntax) s)) -> Q syntax db s (left (QExpr (Sql92SelectExpressionSyntax syntax) s)) -> Q syntax db s (right (QExpr (Sql92SelectExpressionSyntax syntax) s)) -> Q syntax db s (left (QExpr (Sql92SelectExpressionSyntax syntax) s), right (QExpr (Sql92SelectExpressionSyntax syntax) 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 indformation.

manyToManyPassthrough_ :: (Database be db, Table joinThrough, Table left, Table right, Sql92SelectSanityCheck syntax, IsSql92SelectSyntax syntax, SqlEq (QExpr (Sql92SelectExpressionSyntax syntax) s) (PrimaryKey left (QExpr (Sql92SelectExpressionSyntax syntax) s)), SqlEq (QExpr (Sql92SelectExpressionSyntax syntax) s) (PrimaryKey right (QExpr (Sql92SelectExpressionSyntax syntax) s))) => DatabaseEntity be db (TableEntity joinThrough) -> (joinThrough (QExpr (Sql92SelectExpressionSyntax syntax) s) -> PrimaryKey left (QExpr (Sql92SelectExpressionSyntax syntax) s)) -> (joinThrough (QExpr (Sql92SelectExpressionSyntax syntax) s) -> PrimaryKey right (QExpr (Sql92SelectExpressionSyntax syntax) s)) -> Q syntax db s (left (QExpr (Sql92SelectExpressionSyntax syntax) s)) -> Q syntax db s (right (QExpr (Sql92SelectExpressionSyntax syntax) s)) -> Q syntax db s (joinThrough (QExpr (Sql92SelectExpressionSyntax syntax) s), left (QExpr (Sql92SelectExpressionSyntax syntax) s), right (QExpr (Sql92SelectExpressionSyntax syntax) 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 indformation.

One-to-many relationships

type OneToMany db s one many = forall syntax. (IsSql92SelectSyntax syntax, HasTableEquality (Sql92SelectExpressionSyntax syntax) (PrimaryKey one), HasSqlValueSyntax (Sql92ExpressionValueSyntax (Sql92SelectExpressionSyntax syntax)) Bool) => one (QExpr (Sql92SelectExpressionSyntax syntax) s) -> Q syntax db s (many (QExpr (Sql92SelectExpressionSyntax syntax) s))

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

type OneToManyOptional db s tbl rel = forall syntax. (IsSql92SelectSyntax syntax, HasTableEqualityNullable (Sql92SelectExpressionSyntax syntax) (PrimaryKey tbl), HasSqlValueSyntax (Sql92ExpressionValueSyntax (Sql92SelectExpressionSyntax syntax)) Bool, HasSqlValueSyntax (Sql92ExpressionValueSyntax (Sql92SelectExpressionSyntax syntax)) SqlNull) => tbl (QExpr (Sql92SelectExpressionSyntax syntax) s) -> Q syntax db s (rel (Nullable (QExpr (Sql92SelectExpressionSyntax syntax) 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

:: (IsSql92SelectSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax (Sql92SelectExpressionSyntax syntax)) Bool, Database be db, HasTableEquality (Sql92SelectExpressionSyntax syntax) (PrimaryKey tbl), Table tbl, Table rel)

=> DatabaseEntity be db (TableEntity rel)

Table to fetch (many)

-> (rel (QExpr (Sql92SelectExpressionSyntax syntax) s) -> PrimaryKey tbl (QExpr (Sql92SelectExpressionSyntax syntax) s))

Foreign key

-> tbl (QExpr (Sql92SelectExpressionSyntax syntax) s)

-> Q syntax db s (rel (QExpr (Sql92SelectExpressionSyntax syntax) 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

:: (IsSql92SelectSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax (Sql92SelectExpressionSyntax syntax)) Bool, HasSqlValueSyntax (Sql92ExpressionValueSyntax (Sql92SelectExpressionSyntax syntax)) SqlNull, HasTableEqualityNullable (Sql92SelectExpressionSyntax syntax) (PrimaryKey tbl), Database be db, Table tbl, Table rel)

=> DatabaseEntity be db (TableEntity rel)

Table to fetch

-> (rel (QExpr (Sql92SelectExpressionSyntax syntax) s) -> PrimaryKey tbl (Nullable (QExpr (Sql92SelectExpressionSyntax syntax) s)))

Foreign key

-> tbl (QExpr (Sql92SelectExpressionSyntax syntax) s)

-> Q syntax db s (rel (Nullable (QExpr (Sql92SelectExpressionSyntax syntax) 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 db s one many = OneToMany 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 db s tbl rel = OneToManyOptional 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

:: (IsSql92SelectSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax (Sql92SelectExpressionSyntax syntax)) Bool, Database be db, HasTableEquality (Sql92SelectExpressionSyntax syntax) (PrimaryKey tbl), Table tbl, Table rel)

=> DatabaseEntity be db (TableEntity rel)

Table to fetch (many)

-> (rel (QExpr (Sql92SelectExpressionSyntax syntax) s) -> PrimaryKey tbl (QExpr (Sql92SelectExpressionSyntax syntax) s))

Foreign key

-> tbl (QExpr (Sql92SelectExpressionSyntax syntax) s)

-> Q syntax db s (rel (QExpr (Sql92SelectExpressionSyntax syntax) 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

:: (IsSql92SelectSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax (Sql92SelectExpressionSyntax syntax)) Bool, HasSqlValueSyntax (Sql92ExpressionValueSyntax (Sql92SelectExpressionSyntax syntax)) SqlNull, HasTableEqualityNullable (Sql92SelectExpressionSyntax syntax) (PrimaryKey tbl), Database be db, Table tbl, Table rel)

=> DatabaseEntity be db (TableEntity rel)

Table to fetch

-> (rel (QExpr (Sql92SelectExpressionSyntax syntax) s) -> PrimaryKey tbl (Nullable (QExpr (Sql92SelectExpressionSyntax syntax) s)))

Foreign key

-> tbl (QExpr (Sql92SelectExpressionSyntax syntax) s)

-> Q syntax db s (rel (Nullable (QExpr (Sql92SelectExpressionSyntax syntax) 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.

Operators

(&&.) :: IsSql92ExpressionSyntax syntax => QGenExpr context syntax s Bool -> QGenExpr context syntax s Bool -> QGenExpr context syntax s Bool infixr 3

SQL AND operator

(||.) :: IsSql92ExpressionSyntax syntax => QGenExpr context syntax s Bool -> QGenExpr context syntax s Bool -> QGenExpr context syntax s Bool infixr 2

SQL OR operator

(&&?.) :: IsSql92ExpressionSyntax syntax => QGenExpr context syntax s SqlBool -> QGenExpr context syntax s SqlBool -> QGenExpr context syntax s SqlBool infixr 3

SQL AND operator for SqlBool

(||?.) :: IsSql92ExpressionSyntax syntax => QGenExpr context syntax s SqlBool -> QGenExpr context syntax s SqlBool -> QGenExpr context syntax s SqlBool infixr 2

SQL OR operator

like_ :: (IsSqlExpressionSyntaxStringType syntax text, IsSql92ExpressionSyntax syntax) => QExpr syntax s text -> QExpr syntax s text -> QExpr syntax s Bool infix 4

SQL LIKE operator

similarTo_ :: (IsSqlExpressionSyntaxStringType syntax text, IsSql99ExpressionSyntax syntax) => QExpr syntax s text -> QExpr syntax s text -> QExpr syntax s text infix 4

SQL99 SIMILAR TO operator

not_ :: forall syntax context s. IsSql92ExpressionSyntax syntax => QGenExpr context syntax s Bool -> QGenExpr context syntax s Bool

SQL NOT operator

sqlNot_ :: forall syntax context s. IsSql92ExpressionSyntax syntax => QGenExpr context syntax s SqlBool -> QGenExpr context syntax s SqlBool

SQL NOT operator, but operating on SqlBool instead

div_ :: (Integral a, IsSql92ExpressionSyntax syntax) => QGenExpr context syntax s a -> QGenExpr context syntax s a -> QGenExpr context syntax s a infixl 7

SQL / operator

mod_ :: (Integral a, IsSql92ExpressionSyntax syntax) => QGenExpr context syntax s a -> QGenExpr context syntax s a -> QGenExpr context syntax s a infixl 7

SQL % operator

concat_ :: IsSql99ConcatExpressionSyntax syntax => [QGenExpr context syntax s Text] -> QGenExpr context syntax s Text

SQL CONCAT function

ANSI SQL Booleans

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.

isTrue_ :: IsSql92ExpressionSyntax syntax => QGenExpr context syntax s SqlBool -> QGenExpr context syntax s Bool

SQL IS TRUE operator

isNotTrue_ :: IsSql92ExpressionSyntax syntax => QGenExpr context syntax s SqlBool -> QGenExpr context syntax s Bool

SQL IS NOT TRUE operator

isFalse_ :: IsSql92ExpressionSyntax syntax => QGenExpr context syntax s SqlBool -> QGenExpr context syntax s Bool

SQL IS FALSE operator

isNotFalse_ :: IsSql92ExpressionSyntax syntax => QGenExpr context syntax s SqlBool -> QGenExpr context syntax s Bool

SQL IS NOT FALSE operator

isUnknown_ :: IsSql92ExpressionSyntax syntax => QGenExpr context syntax s SqlBool -> QGenExpr context syntax s Bool

SQL IS UNKNOWN operator

isNotUnknown_ :: IsSql92ExpressionSyntax syntax => QGenExpr context syntax s SqlBool -> QGenExpr context syntax s Bool

SQL IS NOT UNKNOWN operator

unknownAs_ :: IsSql92ExpressionSyntax syntax => Bool -> QGenExpr context syntax s SqlBool -> QGenExpr context syntax 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

Unquantified comparison operators

class (IsSql92ExpressionSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) Bool) => HasSqlEqualityCheck syntax a where

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

Methods

sqlEqE :: Proxy a -> syntax -> syntax -> syntax

sqlNeqE :: Proxy a -> syntax -> syntax -> syntax

sqlEqTriE :: Proxy a -> syntax -> syntax -> syntax

Tri-state equality

sqlNeqTriE :: Proxy a -> syntax -> syntax -> syntax

Tri-state equality

Instances

HasSqlEqualityCheck Expression Bool

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Bool -> Expression -> Expression -> Expression

sqlNeqE :: Proxy Bool -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy Bool -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy Bool -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression Double

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Double -> Expression -> Expression -> Expression

sqlNeqE :: Proxy Double -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy Double -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy Double -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression Float

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Float -> Expression -> Expression -> Expression

sqlNeqE :: Proxy Float -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy Float -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy Float -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression Int

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Int -> Expression -> Expression -> Expression

sqlNeqE :: Proxy Int -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy Int -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy Int -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression Int8

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Int8 -> Expression -> Expression -> Expression

sqlNeqE :: Proxy Int8 -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy Int8 -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy Int8 -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression Int16

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Int16 -> Expression -> Expression -> Expression

sqlNeqE :: Proxy Int16 -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy Int16 -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy Int16 -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression Int32

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Int32 -> Expression -> Expression -> Expression

sqlNeqE :: Proxy Int32 -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy Int32 -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy Int32 -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression Int64

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Int64 -> Expression -> Expression -> Expression

sqlNeqE :: Proxy Int64 -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy Int64 -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy Int64 -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression Integer

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Integer -> Expression -> Expression -> Expression

sqlNeqE :: Proxy Integer -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy Integer -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy Integer -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression Word

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Word -> Expression -> Expression -> Expression

sqlNeqE :: Proxy Word -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy Word -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy Word -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression Word8

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Word8 -> Expression -> Expression -> Expression

sqlNeqE :: Proxy Word8 -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy Word8 -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy Word8 -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression Word16

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Word16 -> Expression -> Expression -> Expression

sqlNeqE :: Proxy Word16 -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy Word16 -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy Word16 -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression Word32

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Word32 -> Expression -> Expression -> Expression

sqlNeqE :: Proxy Word32 -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy Word32 -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy Word32 -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression Word64

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Word64 -> Expression -> Expression -> Expression

sqlNeqE :: Proxy Word64 -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy Word64 -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy Word64 -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression Text

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Text -> Expression -> Expression -> Expression

sqlNeqE :: Proxy Text -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy Text -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy Text -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression UTCTime

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy UTCTime -> Expression -> Expression -> Expression

sqlNeqE :: Proxy UTCTime -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy UTCTime -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy UTCTime -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression LocalTime

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy LocalTime -> Expression -> Expression -> Expression

sqlNeqE :: Proxy LocalTime -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy LocalTime -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy LocalTime -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression TimeOfDay

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy TimeOfDay -> Expression -> Expression -> Expression

sqlNeqE :: Proxy TimeOfDay -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy TimeOfDay -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy TimeOfDay -> Expression -> Expression -> Expression

HasSqlEqualityCheck Expression Day

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Day -> Expression -> Expression -> Expression

sqlNeqE :: Proxy Day -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy Day -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy Day -> Expression -> Expression -> Expression

HasSqlEqualityCheck SqlSyntaxBuilder Bool

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Bool -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy Bool -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy Bool -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy Bool -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder Double

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Double -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy Double -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy Double -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy Double -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder Float

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Float -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy Float -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy Float -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy Float -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder Int

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Int -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy Int -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy Int -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy Int -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder Int8

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Int8 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy Int8 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy Int8 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy Int8 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder Int16

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Int16 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy Int16 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy Int16 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy Int16 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder Int32

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Int32 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy Int32 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy Int32 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy Int32 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder Int64

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Int64 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy Int64 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy Int64 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy Int64 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder Integer

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Integer -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy Integer -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy Integer -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy Integer -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder Word

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Word -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy Word -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy Word -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy Word -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder Word8

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Word8 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy Word8 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy Word8 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy Word8 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder Word16

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Word16 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy Word16 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy Word16 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy Word16 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder Word32

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Word32 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy Word32 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy Word32 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy Word32 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder Word64

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Word64 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy Word64 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy Word64 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy Word64 -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder Text

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Text -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy Text -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy Text -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy Text -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder UTCTime

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy UTCTime -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy UTCTime -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy UTCTime -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy UTCTime -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder LocalTime

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy LocalTime -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy LocalTime -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy LocalTime -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy LocalTime -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder TimeOfDay

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy TimeOfDay -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy TimeOfDay -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy TimeOfDay -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy TimeOfDay -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck SqlSyntaxBuilder Day

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy Day -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy Day -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy Day -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy Day -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlEqualityCheck syntax a => HasSqlEqualityCheck syntax (SqlSerial a)

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy (SqlSerial a) -> syntax -> syntax -> syntax

sqlNeqE :: Proxy (SqlSerial a) -> syntax -> syntax -> syntax

sqlEqTriE :: Proxy (SqlSerial a) -> syntax -> syntax -> syntax

sqlNeqTriE :: Proxy (SqlSerial a) -> syntax -> syntax -> syntax

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

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy (Maybe a) -> syntax -> syntax -> syntax

sqlNeqE :: Proxy (Maybe a) -> syntax -> syntax -> syntax

sqlEqTriE :: Proxy (Maybe a) -> syntax -> syntax -> syntax

sqlNeqTriE :: Proxy (Maybe a) -> syntax -> syntax -> syntax

HasSqlEqualityCheck Expression a => HasSqlEqualityCheck Expression (Tagged t a)

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy (Tagged t a) -> Expression -> Expression -> Expression

sqlNeqE :: Proxy (Tagged t a) -> Expression -> Expression -> Expression

sqlEqTriE :: Proxy (Tagged t a) -> Expression -> Expression -> Expression

sqlNeqTriE :: Proxy (Tagged t a) -> Expression -> Expression -> Expression

HasSqlEqualityCheck SqlSyntaxBuilder a => HasSqlEqualityCheck SqlSyntaxBuilder (Tagged t a)

Defined in Database.Beam.Query.Ord

Methods

sqlEqE :: Proxy (Tagged t a) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqE :: Proxy (Tagged t a) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlEqTriE :: Proxy (Tagged t a) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlNeqTriE :: Proxy (Tagged t a) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

class HasSqlEqualityCheck syntax a => HasSqlQuantifiedEqualityCheck syntax a where

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

Methods

sqlQEqE :: Proxy a -> Maybe (Sql92ExpressionQuantifierSyntax syntax) -> syntax -> syntax -> syntax

sqlQNeqE :: Proxy a -> Maybe (Sql92ExpressionQuantifierSyntax syntax) -> syntax -> syntax -> syntax

Instances

HasSqlQuantifiedEqualityCheck Expression Bool

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Bool -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy Bool -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression Double

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Double -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy Double -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression Float

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Float -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy Float -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression Int

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Int -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy Int -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression Int8

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Int8 -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy Int8 -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression Int16

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Int16 -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy Int16 -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression Int32

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Int32 -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy Int32 -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression Int64

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Int64 -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy Int64 -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression Integer

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Integer -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy Integer -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression Word

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Word -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy Word -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression Word8

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Word8 -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy Word8 -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression Word16

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Word16 -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy Word16 -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression Word32

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Word32 -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy Word32 -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression Word64

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Word64 -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy Word64 -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression Text

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Text -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy Text -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression UTCTime

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy UTCTime -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy UTCTime -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression LocalTime

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy LocalTime -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy LocalTime -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression TimeOfDay

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy TimeOfDay -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy TimeOfDay -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck Expression Day

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Day -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy Day -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder Bool

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Bool -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy Bool -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder Double

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Double -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy Double -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder Float

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Float -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy Float -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder Int

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Int -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy Int -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder Int8

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Int8 -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy Int8 -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder Int16

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Int16 -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy Int16 -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder Int32

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Int32 -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy Int32 -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder Int64

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Int64 -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy Int64 -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder Integer

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Integer -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy Integer -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder Word

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Word -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy Word -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder Word8

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Word8 -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy Word8 -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder Word16

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Word16 -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy Word16 -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder Word32

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Word32 -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy Word32 -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder Word64

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Word64 -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy Word64 -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder Text

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Text -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy Text -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder UTCTime

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy UTCTime -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy UTCTime -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder LocalTime

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy LocalTime -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy LocalTime -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder TimeOfDay

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy TimeOfDay -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy TimeOfDay -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder Day

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy Day -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy Day -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

HasSqlQuantifiedEqualityCheck syntax a => HasSqlQuantifiedEqualityCheck syntax (SqlSerial a)

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy (SqlSerial a) -> Maybe (Sql92ExpressionQuantifierSyntax syntax) -> syntax -> syntax -> syntax

sqlQNeqE :: Proxy (SqlSerial a) -> Maybe (Sql92ExpressionQuantifierSyntax syntax) -> syntax -> syntax -> syntax

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

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy (Maybe a) -> Maybe (Sql92ExpressionQuantifierSyntax syntax) -> syntax -> syntax -> syntax

sqlQNeqE :: Proxy (Maybe a) -> Maybe (Sql92ExpressionQuantifierSyntax syntax) -> syntax -> syntax -> syntax

HasSqlQuantifiedEqualityCheck Expression a => HasSqlQuantifiedEqualityCheck Expression (Tagged t a)

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy (Tagged t a) -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

sqlQNeqE :: Proxy (Tagged t a) -> Maybe (Sql92ExpressionQuantifierSyntax Expression) -> Expression -> Expression -> Expression

HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder a => HasSqlQuantifiedEqualityCheck SqlSyntaxBuilder (Tagged t a)

Defined in Database.Beam.Query.Ord

Methods

sqlQEqE :: Proxy (Tagged t a) -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

sqlQNeqE :: Proxy (Tagged t a) -> Maybe (Sql92ExpressionQuantifierSyntax SqlSyntaxBuilder) -> SqlSyntaxBuilder -> SqlSyntaxBuilder -> SqlSyntaxBuilder

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

Minimal complete definition

(==.), (/=.), (==?.), (/=?.)

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

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

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

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

Instances

(IsSql92ExpressionSyntax syntax, FieldsFulfillConstraintNullable (HasSqlEqualityCheck syntax) tbl, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) Bool, Beamable tbl) => SqlEq (QGenExpr context syntax s) (tbl (Nullable (QGenExpr context syntax s)))

Defined in Database.Beam.Query.Ord

Methods

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

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

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

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

(IsSql92ExpressionSyntax syntax, FieldsFulfillConstraint (HasSqlEqualityCheck syntax) tbl, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) Bool, Beamable tbl) => SqlEq (QGenExpr context syntax s) (tbl (QGenExpr context syntax s))

Compare two arbitrary Beamable types containing QGenExprs for equality.

Defined in Database.Beam.Query.Ord

Methods

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

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

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

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

(IsSql92ExpressionSyntax syntax, HasSqlEqualityCheck syntax a) => SqlEq (QGenExpr context syntax s) (QGenExpr context syntax s a)

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

Defined in Database.Beam.Query.Ord

Methods

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

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

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

(/=?.) :: QGenExpr context syntax s a -> QGenExpr context syntax s a -> QGenExpr context syntax 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.

Minimal complete definition

(<.), (>.), (<=.), (>=.)

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

IsSql92ExpressionSyntax syntax => SqlOrd (QGenExpr context syntax s) (QGenExpr context syntax s a)

Defined in Database.Beam.Query.Ord

Methods

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

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

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

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

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.

Minimal complete definition

(==*.), (/=*.)

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

(IsSql92ExpressionSyntax syntax, HasSqlQuantifiedEqualityCheck syntax a) => SqlEqQuantified (QGenExpr context syntax s) (QQuantified syntax s a) (QGenExpr context syntax s a)

Two arbitrary expressions can be quantifiably compared for equality.

Defined in Database.Beam.Query.Ord

Methods

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

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

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

Class for things which can be quantifiably compared.

Minimal complete definition

(<*.), (>*.), (<=*.), (>=*.)

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

IsSql92ExpressionSyntax syntax => SqlOrdQuantified (QGenExpr context syntax s) (QQuantified syntax s a) (QGenExpr context syntax s a)

Defined in Database.Beam.Query.Ord

Methods

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

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

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

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

data QQuantified expr s r

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

Instances

IsSql92ExpressionSyntax syntax => SqlOrdQuantified (QGenExpr context syntax s) (QQuantified syntax s a) (QGenExpr context syntax s a)

Defined in Database.Beam.Query.Ord

Methods

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

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

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

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

(IsSql92ExpressionSyntax syntax, HasSqlQuantifiedEqualityCheck syntax a) => SqlEqQuantified (QGenExpr context syntax s) (QQuantified syntax s a) (QGenExpr context syntax s a)

Two arbitrary expressions can be quantifiably compared for equality.

Defined in Database.Beam.Query.Ord

Methods

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

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

anyOf_ :: forall s a select expr db. (IsSql92SelectSyntax select, IsSql92ExpressionSyntax expr, HasQBuilder select, Sql92ExpressionSelectSyntax expr ~ select) => Q select db (QNested s) (QExpr (Sql92SelectExpressionSyntax select) (QNested s) a) -> QQuantified expr 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 select expr db. (IsSql92SelectSyntax select, IsSql92ExpressionSyntax expr, HasQBuilder select, Sql92ExpressionSelectSyntax expr ~ select) => Q select db (QNested s) (QExpr (Sql92SelectExpressionSyntax select) (QNested s) a) -> QQuantified expr 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 expr. IsSql92ExpressionSyntax expr => [QExpr expr s a] -> QQuantified expr 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 expr. IsSql92ExpressionSyntax expr => [QExpr expr s a] -> QQuantified expr 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_ :: IsSql92ExpressionSyntax syntax => QGenExpr context syntax s a -> QGenExpr context syntax s a -> QGenExpr context syntax s a -> QGenExpr context syntax s Bool infix 4

SQL BETWEEN clause

in_ :: (IsSql92ExpressionSyntax syntax, HasSqlValueSyntax (Sql92ExpressionValueSyntax syntax) Bool) => QGenExpr context syntax s a -> [QGenExpr context syntax s a] -> QGenExpr context syntax s Bool infix 4

SQL IN predicate

Aggregates

See the corresponding manual section for more detail

aggregate_

Arguments

:: (ProjectibleWithPredicate AggregateContext (Sql92SelectExpressionSyntax select) a, Projectible (Sql92SelectExpressionSyntax select) r, Projectible (Sql92SelectExpressionSyntax select) a, ContextRewritable a, ThreadRewritable (QNested s) (WithRewrittenContext a QValueContext), IsSql92SelectSyntax select)

=> (r -> a)

Aggregate projection

-> Q select db (QNested s) r

Query to aggregate over

-> Q select 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 QExprs).

For usage examples, see the manual.

filterWhere_ :: IsSql2003ExpressionElementaryOLAPOperationsSyntax expr => QAgg expr s a -> QExpr expr s Bool -> QAgg expr s a

Support for FILTER (WHERE ...) syntax for aggregates. Part of SQL2003 Advanced OLAP operations feature (T612).

See filterWhere_' for a version that accepts SqlBool.

filterWhere_' :: IsSql2003ExpressionElementaryOLAPOperationsSyntax expr => QAgg expr s a -> QExpr expr s SqlBool -> QAgg expr 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).

Minimal complete definition

group_

Methods

group_ :: expr -> grouped

Instances

Beamable tbl => QGroupable (tbl (QExpr expr s)) (tbl (QGroupExpr expr 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 expr s) -> tbl (QGroupExpr expr s)

QGroupable (QExpr expr s a) (QGroupExpr expr s a)

group_ for simple value expressions.

Defined in Database.Beam.Query.Aggregate

Methods

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

General-purpose aggregate functions

sum_ :: (IsSql92AggregationExpressionSyntax expr, Num a) => QExpr expr s a -> QAgg expr s (Maybe a)

SQL SUM(ALL ..) function (but without the explicit ALL)

avg_ :: (IsSql92AggregationExpressionSyntax expr, Num a) => QExpr expr s a -> QAgg expr s (Maybe a)

SQL AVG(ALL ..) function (but without the explicit ALL)

min_ :: IsSql92AggregationExpressionSyntax expr => QExpr expr s a -> QAgg expr s (Maybe a)

SQL MIN(ALL ..) function (but without the explicit ALL)

max_ :: IsSql92AggregationExpressionSyntax expr => QExpr expr s a -> QAgg expr s (Maybe a)

SQL MAX(ALL ..) function (but without the explicit ALL)

count_ :: (IsSql92AggregationExpressionSyntax expr, Integral b) => QExpr expr s a -> QAgg expr s b

SQL COUNT(ALL ..) function (but without the explicit ALL)

countAll_ :: IsSql92AggregationExpressionSyntax expr => QAgg expr s Int

SQL COUNT(*) function

rank_ :: IsSql2003ExpressionElementaryOLAPOperationsSyntax expr => QAgg expr s Int

SQL2003 RANK function (Requires T611 Elementary OLAP operations support)

cumeDist_ :: IsSql2003ExpressionAdvancedOLAPOperationsSyntax expr => QAgg expr s Double

SQL2003 CUME_DIST function (Requires T612 Advanced OLAP operations support)

percentRank_ :: IsSql2003ExpressionAdvancedOLAPOperationsSyntax expr => QAgg expr s Double

SQL2003 PERCENT_RANK function (Requires T612 Advanced OLAP operations support)

denseRank_ :: IsSql2003ExpressionAdvancedOLAPOperationsSyntax expr => QAgg expr s Int

every_ :: IsSql99AggregationExpressionSyntax expr => QExpr expr s SqlBool -> QAgg expr s SqlBool

SQL99 EVERY(ALL ..) function (but without the explicit ALL)

any_ :: IsSql99AggregationExpressionSyntax expr => QExpr expr s SqlBool -> QAgg expr s SqlBool

SQL99 ANY(ALL ..) function (but without the explicit ALL)

some_ :: IsSql99AggregationExpressionSyntax expr => QExpr expr s SqlBool -> QAgg expr 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_ :: (IsSql92AggregationExpressionSyntax expr, Num a) => Maybe (Sql92AggregationSetQuantifierSyntax expr) -> QExpr expr s a -> QAgg expr s (Maybe a)

avgOver_ :: (IsSql92AggregationExpressionSyntax expr, Num a) => Maybe (Sql92AggregationSetQuantifierSyntax expr) -> QExpr expr s a -> QAgg expr s (Maybe a)

minOver_ :: IsSql92AggregationExpressionSyntax expr => Maybe (Sql92AggregationSetQuantifierSyntax expr) -> QExpr expr s a -> QAgg expr s (Maybe a)

maxOver_ :: IsSql92AggregationExpressionSyntax expr => Maybe (Sql92AggregationSetQuantifierSyntax expr) -> QExpr expr s a -> QAgg expr s (Maybe a)

countOver_ :: (IsSql92AggregationExpressionSyntax expr, Integral b) => Maybe (Sql92AggregationSetQuantifierSyntax expr) -> QExpr expr s a -> QAgg expr s b

everyOver_ :: IsSql99AggregationExpressionSyntax expr => Maybe (Sql92AggregationSetQuantifierSyntax expr) -> QExpr expr s SqlBool -> QAgg expr 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_ :: IsSql99AggregationExpressionSyntax expr => Maybe (Sql92AggregationSetQuantifierSyntax expr) -> QExpr expr s SqlBool -> QAgg expr 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_ :: IsSql99AggregationExpressionSyntax expr => Maybe (Sql92AggregationSetQuantifierSyntax expr) -> QExpr expr s SqlBool -> QAgg expr 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

SQL Command construction and execution

SELECT

newtype SqlSelect select a

Represents a select statement over the syntax select that will return rows of type a.

Constructors

SqlSelect select

select :: forall syntax db res. (ProjectibleInSelectSyntax syntax res, IsSql92SelectSyntax syntax, HasQBuilder syntax) => Q syntax db QueryInaccessible res -> SqlSelect syntax (QExprToIdentity res)

Build a SqlSelect for the given Q.

lookup_ :: (HasQBuilder syntax, Sql92SelectSanityCheck syntax, SqlValableTable (PrimaryKey table) (Sql92SelectExpressionSyntax syntax), HasSqlValueSyntax (Sql92ExpressionValueSyntax (Sql92SelectExpressionSyntax syntax)) Bool, HasTableEquality (Sql92SelectExpressionSyntax syntax) (PrimaryKey table), Beamable table, Table table, Database be db) => DatabaseEntity be db (TableEntity table) -> PrimaryKey table Identity -> SqlSelect syntax (table Identity)

Convenience function to generate a SqlSelect that looks up a table row given a primary key.

runSelectReturningList :: (IsSql92Syntax cmd, MonadBeam cmd be hdl m, FromBackendRow be a) => SqlSelect (Sql92SelectSyntax cmd) a -> m [a]

Run a SqlSelect in a MonadBeam and get the results as a list

runSelectReturningOne :: (IsSql92Syntax cmd, MonadBeam cmd be hdl m, FromBackendRow be a) => SqlSelect (Sql92SelectSyntax cmd) 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.

dumpSqlSelect :: ProjectibleInSelectSyntax SqlSyntaxBuilder res => Q SqlSyntaxBuilder db QueryInaccessible 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 syntax

Represents a SQL INSERT command that has not yet been run

Constructors

SqlInsert syntax

SqlInsertNoRows

insert

Arguments

:: (IsSql92InsertSyntax syntax, Projectible Text (table (QField s)))

=> DatabaseEntity be db (TableEntity table)

Table to insert into

-> SqlInsertValues (Sql92InsertValuesSyntax syntax) (table (QExpr (Sql92InsertExpressionSyntax syntax) s))

Values to insert. See insertValues, insertExpressions, and insertFrom for possibilities.

-> SqlInsert syntax

Generate a SqlInsert given a table and a source of values.

insertOnly

Arguments

:: (IsSql92InsertSyntax syntax, Projectible Text (QExprToField r))

=> DatabaseEntity be db (TableEntity table)

Table to insert into

-> (table (QField s) -> QExprToField r)

-> SqlInsertValues (Sql92InsertValuesSyntax syntax) r

Values to insert. See insertValues, insertExpressions, insertData, and insertFrom for possibilities.

-> SqlInsert syntax

Generate a SqlInsert over only certain fields of a table

runInsert :: (IsSql92Syntax cmd, MonadBeam cmd be hdl m) => SqlInsert (Sql92InsertSyntax cmd) -> m ()

Run a SqlInsert in a MonadBeam

data SqlInsertValues insertValues proj

Represents a source of values that can be inserted into a table shaped like tbl.

Constructors

SqlInsertValues insertValues

SqlInsertValuesEmpty

insertExpressions :: forall syntax table s. (Beamable table, IsSql92InsertValuesSyntax syntax) => (forall s'. [table (QExpr (Sql92InsertValuesExpressionSyntax syntax) s')]) -> SqlInsertValues syntax (table (QExpr (Sql92InsertValuesExpressionSyntax syntax) s))

Build a SqlInsertValues from series of expressions in tables

insertValues :: forall table syntax s. (Beamable table, IsSql92InsertValuesSyntax syntax, FieldsFulfillConstraint (HasSqlValueSyntax (Sql92ExpressionValueSyntax (Sql92InsertValuesExpressionSyntax syntax))) table) => [table Identity] -> SqlInsertValues syntax (table (QExpr (Sql92InsertValuesExpressionSyntax syntax) s))

Build a SqlInsertValues from concrete table values

insertFrom :: (IsSql92InsertValuesSyntax syntax, HasQBuilder (Sql92InsertValuesSelectSyntax syntax), Projectible (Sql92SelectExpressionSyntax (Sql92InsertValuesSelectSyntax syntax)) r) => Q (Sql92InsertValuesSelectSyntax syntax) db QueryInaccessible r -> SqlInsertValues syntax r

Build a SqlInsertValues from a SqlSelect that returns the same table

insertData :: forall syntax r. (Projectible (Sql92InsertValuesExpressionSyntax syntax) r, IsSql92InsertValuesSyntax syntax) => [r] -> SqlInsertValues syntax r

Build a SqlInsertValues from arbitrarily shaped data containing expressions

UPDATE

data SqlUpdate syntax (table :: (* -> *) -> *)

Represents a SQL UPDATE statement for the given table.

Constructors

SqlUpdate syntax

SqlIdentityUpdate

update

Arguments

:: (Beamable table, IsSql92UpdateSyntax syntax)

=> DatabaseEntity be db (TableEntity table)

The table to insert into

-> (forall s. table (QField s) -> [QAssignment (Sql92UpdateFieldNameSyntax syntax) (Sql92UpdateExpressionSyntax syntax) s])

A sequence of assignments to make.

-> (forall s. table (QExpr (Sql92UpdateExpressionSyntax syntax) s) -> QExpr (Sql92UpdateExpressionSyntax syntax) s Bool)

Build a WHERE clause given a table containing expressions

-> SqlUpdate syntax table

Build a SqlUpdate given a table, a list of assignments, and a way to build a WHERE clause.

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 QExpr.

save

Arguments

:: (Table table, IsSql92UpdateSyntax syntax, SqlValableTable (PrimaryKey table) (Sql92UpdateExpressionSyntax syntax), SqlValableTable table (Sql92UpdateExpressionSyntax syntax), HasTableEquality (Sql92UpdateExpressionSyntax syntax) (PrimaryKey table), HasSqlValueSyntax (Sql92ExpressionValueSyntax (Sql92UpdateExpressionSyntax syntax)) Bool)

=> DatabaseEntity be db (TableEntity table)

Table to update

-> table Identity

Value to set to

-> SqlUpdate syntax table

Generate a SqlUpdate that will update the given table 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.

runUpdate :: (IsSql92Syntax cmd, MonadBeam cmd be hdl m) => SqlUpdate (Sql92UpdateSyntax cmd) tbl -> m ()

Run a SqlUpdate in a MonadBeam.

DELETE

newtype SqlDelete syntax (table :: (* -> *) -> *)

Represents a SQL DELETE statement for the given table

Constructors

SqlDelete syntax

delete

Arguments

:: IsSql92DeleteSyntax delete

=> DatabaseEntity be db (TableEntity table)

Table to delete from

-> (forall s. (forall s'. table (QExpr (Sql92DeleteExpressionSyntax delete) s')) -> QExpr (Sql92DeleteExpressionSyntax delete) s Bool)

Build a WHERE clause given a table containing expressions

-> SqlDelete delete table

Build a SqlDelete from a table and a way to build a WHERE clause

runDelete :: (IsSql92Syntax cmd, MonadBeam cmd be hdl m) => SqlDelete (Sql92DeleteSyntax cmd) table -> m ()

Run a SqlDelete in a MonadBeam