Database.Esqueleto.Compat.Operators

Documentation

class SqlAssignment a b c where

A class for assigning a value in SQL, shared among the persistent and esqueleto libraries.

Methods

(=.) :: a -> b -> c infixr 3

(-=.) :: a -> b -> c

(+=.) :: a -> b -> c

(*=.) :: a -> b -> c

Instances

(PersistField typ, field ~ EntityField rec typ', typ ~ typ') => SqlAssignment field typ (Update rec)

Defined in Database.Esqueleto.Compat.Operators

Methods

(=.) :: field -> typ -> Update rec

(-=.) :: field -> typ -> Update rec

(+=.) :: field -> typ -> Update rec

(*=.) :: field -> typ -> Update rec

(PersistEntity rec, PersistField typ, field ~ EntityField rec typ) => SqlAssignment field (SqlExpr (Value typ)) (SqlExpr (Entity rec) -> SqlExpr Update)

Defined in Database.Esqueleto.Compat.Operators

Methods

(=.) :: field -> SqlExpr (Value typ) -> SqlExpr (Entity rec) -> SqlExpr Update

(-=.) :: field -> SqlExpr (Value typ) -> SqlExpr (Entity rec) -> SqlExpr Update

(+=.) :: field -> SqlExpr (Value typ) -> SqlExpr (Entity rec) -> SqlExpr Update

(*=.) :: field -> SqlExpr (Value typ) -> SqlExpr (Entity rec) -> SqlExpr Update

class SqlBoolean a where

A class for abstracting over Bool-like operations.

Irritatingly, we can't have not_ in here, because persistent actually doesn't have such a function! That's why the SqlBooleanNot class exists.

Methods

true_ :: a

false_ :: a

(||.) :: a -> a -> a infixr 2

(&&.) :: a -> a -> a infixr 3

Instances

a ~ Bool => SqlBoolean (SqlExpr (Value a))

SqlExpr can be compared as SqlBoolean values, provided that they contain a Value Bool.

The implementation uses the (a ~ Bool) equality constraint so that polymorphic definitions don't get too confused.

Defined in Database.Esqueleto.Compat.Operators

Methods

true_ :: SqlExpr (Value a)

false_ :: SqlExpr (Value a)

(||.) :: SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)

(&&.) :: SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)

SqlBoolean [Filter k]

This is a bit of a weird definition.

Turns out, ||. is very rarely used in the codebase - we actually have more uses of FilterOr! And there *isn't* a &&. in persistent at all.

Defined in Database.Esqueleto.Compat.Operators

Methods

true_ :: [Filter k]

false_ :: [Filter k]

(||.) :: [Filter k] -> [Filter k] -> [Filter k]

(&&.) :: [Filter k] -> [Filter k] -> [Filter k]

class SqlBoolean a => SqlBooleanNot a where

Methods

not_ :: a -> a

Instances

a ~ Bool => SqlBooleanNot (SqlExpr (Value a))

Defined in Database.Esqueleto.Compat.Operators

Methods

not_ :: SqlExpr (Value a) -> SqlExpr (Value a)

(TypeError ('Text "`persistent` does not have a `not_` operator for filters. Instead, use the " :$$: 'Text "inverse operator, like `<.` instead of `>=.`.") :: Constraint) => SqlBooleanNot [Filter t]

A TypeError instance is provided so that folks don't get too confused, though I doubt they'll run into this.

Defined in Database.Esqueleto.Compat.Operators

Methods

not_ :: [Filter t] -> [Filter t]

class SqlComparison a b c | c a -> b, c b -> a, a b -> c where

A class for comparing for equality in persistent and esqueleto. The first two type parameters are the inputs to the binary operator, and the final one is the result type.

Methods

(==.) :: a -> b -> c infix 4

(!=.) :: a -> b -> c infix 4

(>.) :: a -> b -> c infix 4

(>=.) :: a -> b -> c infix 4

(<.) :: a -> b -> c infix 4

(<=.) :: a -> b -> c infix 4

Instances

(PersistField a, a ~ b, lhs ~ SqlExpr (Value a), c ~ Bool) => SqlComparison (SqlExpr (Value a)) (SqlExpr (Value b)) (SqlExpr (Value c))

Defined in Database.Esqueleto.Compat.Operators

Methods

(==.) :: SqlExpr (Value a) -> SqlExpr (Value b) -> SqlExpr (Value c)

(!=.) :: SqlExpr (Value a) -> SqlExpr (Value b) -> SqlExpr (Value c)

(>.) :: SqlExpr (Value a) -> SqlExpr (Value b) -> SqlExpr (Value c)

(>=.) :: SqlExpr (Value a) -> SqlExpr (Value b) -> SqlExpr (Value c)

(<.) :: SqlExpr (Value a) -> SqlExpr (Value b) -> SqlExpr (Value c)

(<=.) :: SqlExpr (Value a) -> SqlExpr (Value b) -> SqlExpr (Value c)

(lhs ~ EntityField rec typ, PersistField typ, typ ~ typ', NotSqlExprEq rec typ typ', rec ~ rec') => SqlComparison (EntityField rec typ) typ' (Filter rec')

Defined in Database.Esqueleto.Compat.Operators

Methods

(==.) :: EntityField rec typ -> typ' -> Filter rec'

(!=.) :: EntityField rec typ -> typ' -> Filter rec'

(>.) :: EntityField rec typ -> typ' -> Filter rec'

(>=.) :: EntityField rec typ -> typ' -> Filter rec'

(<.) :: EntityField rec typ -> typ' -> Filter rec'

(<=.) :: EntityField rec typ -> typ' -> Filter rec'

type family NotSqlExprEq rec typ' typ :: Constraint where ...

Equations

NotSqlExprEq rec typ' (SqlExpr (Value _)) = TypeError (NotSqlExprEqMessage rec typ')

NotSqlExprEq _ _ _ = ()

type NotSqlExprEqMessage rec typ = (((('Text "You used a bare `" :<>: 'ShowType (EntityField rec typ)) :<>: 'Text "` field.") :$$: 'Text "If you're writing a Persistent expression, you don't need to use `val`.") :$$: 'Text "If you're writing an esqueleto expression, you need to project from a ") :$$: 'Text "table variable, like: e ^. FooName"

(/=.) :: SqlComparison a b c => a -> b -> c infix 4

An alias for !=., in keeping with the convention of having Haskell-ish operators.