Safe Haskell | None |
---|---|

Language | Haskell2010 |

Unsafe operations giving the user unchecked low-level control over the generated SQL.

## Synopsis

- fun :: Text -> Col s a -> Col s b
- fun2 :: Text -> Col s a -> Col s b -> Col s c
- fun0 :: Text -> Col s a
- operator :: Text -> Col s a -> Col s b -> Col s c
- aggr :: SqlType a => Text -> Col s a -> Aggr s b
- cast :: forall s a b. SqlType b => Col s a -> Col s b
- castAggr :: forall s a b. SqlType b => Aggr s a -> Aggr s b
- sink :: (f s a -> f s b) -> f (Inner s) a -> f (Inner s) b
- sink2 :: (f s a -> f s b -> f s c) -> f (Inner s) a -> f (Inner s) b -> f (Inner s) c
- unsafeSelector :: (SqlRow a, SqlType b) => Int -> Selector a b

# Documentation

fun :: Text -> Col s a -> Col s b Source #

A unary operation. Note that the provided function name is spliced directly into the resulting SQL query. Thus, this function should ONLY be used to implement well-defined functions that are missing from Selda's standard library, and NOT in an ad hoc manner during queries.

operator :: Text -> Col s a -> Col s b -> Col s c Source #

A custom operator. `operator "~>" a b`

will compile down to
`a ~> b`

, with parentheses around `a`

and `b`

iff they are not atomic.
This means that SQL operator precedence is disregarded, as all
subexpressions are parenthesized. In the following example for instance,
`foo a b c`

will compile down to `(a ~> b) ~> c`

.

(~>) = operator "~>" infixl 5 ~> foo a b c = a ~> b ~> c

aggr :: SqlType a => Text -> Col s a -> Aggr s b Source #

Create a named aggregate function.
Like `fun`

, this function is generally unsafe and should ONLY be used
to implement missing backend-specific functionality.

cast :: forall s a b. SqlType b => Col s a -> Col s b Source #

Cast a column to another type, using whichever coercion semantics are used by the underlying SQL implementation.

castAggr :: forall s a b. SqlType b => Aggr s a -> Aggr s b Source #

Cast an aggregate to another type, using whichever coercion semantics are used by the underlying SQL implementation.

sink :: (f s a -> f s b) -> f (Inner s) a -> f (Inner s) b Source #

Sink the given function into an inner scope.

Be careful not to use this function with functions capturing rows or columns from an outer scope. For instance, the following usage will likely lead to disaster:

query $ do x <- #age `from` select person inner $ sink (\p -> x + (p ! #age)) <$> select person

Really, if you have to use this function, ONLY do so in the global scope.