Database.Esqueleto.Experimental

Setup

If you're already using Database.Esqueleto, then you can get started using this module just by changing your imports slightly, as well as enabling the TypeApplications extension.

{-# LANGUAGE TypeApplications #-}

...

import Database.Esqueleto hiding (on, from)
import Database.Esqueleto.Experimental

Introduction

This module is fully backwards-compatible extension to the esqueleto EDSL that expands subquery functionality and enables SQL set operations to be written directly in Haskell. Specifically, this enables:

• Subqueries in JOIN statements
• UNION
• UNION ALL
• INTERSECT
• EXCEPT

As a consequence of this, several classes of runtime errors are now caught at compile time. This includes missing on clauses and improper handling of Maybe values in outer joins.

This module can be used in conjunction with the main Database.Esqueleto module, but doing so requires qualified imports to avoid ambiguous definitions of on and from, which are defined in both modules.

Below we will give an overview of how to use this module and the features it enables.

A New Syntax

This module introduces a new syntax that serves to enable the aforementioned features. This new syntax also changes how joins written in the esqueleto EDSL to more closely resemble the underlying SQL.

For our examples, we'll use a schema similar to the one in the Getting Started section of Database.Esqueleto:

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persist|
  Person
    name String
    age Int Maybe
    deriving Eq Show
  BlogPost
    title String
    authorId PersonId
    deriving Eq Show
  Follow
    follower PersonId
    followed PersonId
    deriving Eq Show
|]

Example 1: Simple select

Let's select all people who are named "John".

Database.Esqueleto:

select $
from $ \people -> do
where_ (people ^. PersonName ==. val "John")
pure people

Database.Esqueleto.Experimental:

select $ do
people <- from $ Table @Person
where_ (people ^. PersonName ==. val "John")
pure people

Example 2: Select with join

Let's select all people and their blog posts who are over the age of 18.

Database.Esqueleto:

select $
from $ \(people `LeftOuterJoin` blogPosts) -> do
on (people ^. PersonId ==. blogPosts ?. BlogPostAuthorId)
where_ (people ^. PersonAge >. val 18)
pure (people, blogPosts)

Database.Esqueleto.Experimental:

Here we use the :& operator to pattern match against the joined tables.

select $ do
(people :& blogPosts) <-
    from $ Table @Person
    `LeftOuterJoin` Table @BlogPost
    `on` (\(people :& blogPosts) ->
            people ^. PersonId ==. blogPosts ?. BlogPostAuthorId)
where_ (people ^. PersonAge >. val 18)
pure (people, blogPosts)

Example 3: Select with multi-table join

Let's select all people who follow a person named "John", including the name of each follower.

Database.Esqueleto:

select $
from $ \(
 people1
 `InnerJoin` followers
 `InnerJoin` people2
) -> do
on (people1 ^. PersonId ==. followers ^. FollowFollowed)
on (followers ^. FollowFollower ==. people2 ^. PersonId)
where_ (people1 ^. PersonName ==. val "John")
pure (followers, people2)

Database.Esqueleto.Experimental:

In this version, with each successive on clause, only the tables we have already joined into are in scope, so we must pattern match accordingly. In this case, in the second InnerJoin, we do not use the first Person reference, so we use _ as a placeholder to ignore it. This prevents a possible runtime error where a table is referenced before it appears in the sequence of JOINs.

select $ do
(people1 :& followers :& people2) <-
    from $ Table @Person
    `InnerJoin` Table @Follow
    `on` (\(people1 :& followers) ->
            people1 ^. PersonId ==. followers ^. FollowFollowed)
    `InnerJoin` Table @Person
    `on` (\(_ :& followers :& people2) ->
            followers ^. FollowFollower ==. people2 ^. PersonId)
where_ (people1 ^. PersonName ==. val "John")
pure (followers, people2)

Example 4: Counting results of a subquery

Let's count the number of people who have posted at least 10 posts

Database.Esqueleto:

select $ pure $ subSelectCount $
from $ \(
  people
  `InnerJoin` blogPosts
) -> do
on (people ^. PersonId ==. blogPosts ^. BlogPostAuthorId)
groupBy (people ^. PersonId)
having ((count $ blogPosts ^. BlogPostId) >. val 10)
pure people

Database.Esqueleto.Experimental:

select $ do
peopleWithPosts <-
  from $ SelectQuery $ do
    (people :& blogPosts) <-
      from $ Table @Person
      `InnerJoin` Table @BlogPost
      `on` (\(p :& bP) ->
              p ^. PersonId ==. bP ^. BlogPostAuthorId)
    groupBy (people ^. PersonId)
    having ((count $ blogPosts ^. BlogPostId) >. val 10)
    pure people
pure $ count (peopleWithPosts ^. PersonId)

We now have the ability to refactor this

Example 5: Sorting the results of a UNION with limits

Out of all of the posts created by a person and the people they follow, generate a list of the first 25 posts, sorted alphabetically.

Database.Esqueleto:

Since UNION is not supported, this requires using rawSql. (Not shown)

Database.Esqueleto.Experimental:

Since this module supports all set operations (see SqlSetOperation), we can use Union to write this query.

select $ do
(authors, blogPosts) <- from $
  (SelectQuery $ do
    (author :& blogPost) <-
      from $ Table @Person
      `InnerJoin` Table @BlogPost
      `on` (\(a :& bP) ->
              a ^. PersonId ==. bP ^. BlogPostAuthorId)
    where_ (author ^. PersonId ==. val currentPersonId)
    pure (author, blogPost)
  )
  `Union`
  (SelectQuery $ do
    (follow :& blogPost :& author) <-
      from $ Table @Follow
      `InnerJoin` Table @BlogPost
      `on` (\(f :& bP) ->
              f ^. FollowFollowed ==. bP ^. BlogPostAuthorId)
      `InnerJoin` Table @Person
      `on` (\(_ :& bP :& a) ->
              bP ^. BlogPostAuthorId ==. a ^. PersonId)
    where_ (follow ^. FollowFollower ==. val currentPersonId)
    pure (author, blogPost)
  )
orderBy [ asc (blogPosts ^. BlogPostTitle) ]
limit 25
pure (authors, blogPosts)

Documentation

data SqlSetOperation a

Data type that represents SQL set operations. This includes UNION, UNION ALL, EXCEPT, and INTERSECT. This data type is defined as a binary tree, with SelectQuery on the leaves.

Each constructor corresponding to the aforementioned set operations can be used as an infix function in a from to help with readability and lead to code that closely resembles the underlying SQL. For example,

select $ from $
  (SelectQuery ...)
  `Union`
  (SelectQuery ...)

is translated into

SELECT * FROM (
  (SELECT * FROM ...)
  UNION
  (SELECT * FROM ...)
)

SelectQuery can be used without any of the set operations to construct a subquery. This can be used in JOIN trees. For example,

select $ from $
  Table @SomeTable
  `InnerJoin` (SelectQuery ...)
  `on` ...

is translated into

SELECT *
FROM SomeTable
INNER JOIN (SELECT * FROM ...)
ON ...

Constructors

Union (SqlSetOperation a) (SqlSetOperation a)

UnionAll (SqlSetOperation a) (SqlSetOperation a)

Except (SqlSetOperation a) (SqlSetOperation a)

Intersect (SqlSetOperation a) (SqlSetOperation a)

SelectQuery (SqlQuery a)

Instances

(SqlSelect a' r, SqlSelect a'' r', ToAlias a, a' ~ ToAliasT a, ToAliasReference a', ToAliasReferenceT a' ~ a'') => ToFrom (SqlSetOperation a)

Defined in Database.Esqueleto.Experimental

Methods

toFrom :: SqlSetOperation a -> From (ToFromT (SqlSetOperation a))

data From a where

Data type that represents the syntax of a JOIN tree. In practice, only the Table constructor is used directly when writing queries. For example,

select $ from $ Table @People

Constructors

Table :: PersistEntity ent => From (SqlExpr (Entity ent))

SubQuery :: (SqlSelect a' r, SqlSelect a'' r', ToAlias a, a' ~ ToAliasT a, ToAliasReference a', ToAliasReferenceT a' ~ a'') => SqlQuery a -> From a''

SqlSetOperation :: (SqlSelect a' r, ToAlias a, a' ~ ToAliasT a, ToAliasReference a', ToAliasReferenceT a' ~ a'') => SqlSetOperation a -> From a''

InnerJoinFrom :: From a -> (From b, (a :& b) -> SqlExpr (Value Bool)) -> From (a :& b)

CrossJoinFrom :: From a -> From b -> From (a :& b)

LeftJoinFrom :: ToMaybe b => From a -> (From b, (a :& ToMaybeT b) -> SqlExpr (Value Bool)) -> From (a :& ToMaybeT b)

RightJoinFrom :: ToMaybe a => From a -> (From b, (ToMaybeT a :& b) -> SqlExpr (Value Bool)) -> From (ToMaybeT a :& b)

FullJoinFrom :: (ToMaybe a, ToMaybe b) => From a -> (From b, (ToMaybeT a :& ToMaybeT b) -> SqlExpr (Value Bool)) -> From (ToMaybeT a :& ToMaybeT b)

Instances

ToFrom (From a)

Defined in Database.Esqueleto.Experimental

Methods

toFrom :: From a -> From (ToFromT (From a))

on :: ToFrom a => a -> (b -> SqlExpr (Value Bool)) -> (a, b -> SqlExpr (Value Bool)) infix 9

An ON clause that describes how two tables are related. This should be used as an infix operator after a JOIN. For example,

select $
from $ Table @Person
`InnerJoin` Table @BlogPost
`on` (\(p :& bP) ->
        p ^. PersonId ==. bP ^. BlogPostAuthorId)

from :: ToFrom a => a -> SqlQuery (ToFromT a)

FROM clause, used to bring entities into scope.

Internally, this function uses the From datatype and the ToFrom typeclass. Unlike the old from, this does not take a function as a parameter, but rather a value that represents a JOIN tree constructed out of instances of ToFrom. This implementation eliminates certain types of runtime errors by preventing the construction of invalid SQL (e.g. illegal nested-from).

data a :& b infixl 2

A left-precedence pair. Pronounced "and". Used to represent expressions that have been joined together.

The precedence behavior can be demonstrated by:

a :& b :& c == ((a :& b) :& c)

See the examples at the beginning of this module to see how this operator is used in JOIN operations.

Constructors

a :& b infixl 2

Instances

(ToMaybe a, ToMaybe b) => ToMaybe (a :& b)

Defined in Database.Esqueleto.Experimental

Methods

toMaybe :: (a :& b) -> ToMaybeT (a :& b)

(ToFrom a, ToFromT a ~ a', ToFrom b, ToFromT b ~ b', ToMaybe a', ma ~ ToMaybeT a', ToMaybe b', mb ~ ToMaybeT b') => ToFrom (FullOuterJoin a (b, (ma :& mb) -> SqlExpr (Value Bool)))

Defined in Database.Esqueleto.Experimental

Methods

toFrom :: FullOuterJoin a (b, (ma :& mb) -> SqlExpr (Value Bool)) -> From (ToFromT (FullOuterJoin a (b, (ma :& mb) -> SqlExpr (Value Bool))))

(ToFrom a, ToFromT a ~ a', ToFrom b, ToFromT b ~ b', ToMaybe a', ma ~ ToMaybeT a') => ToFrom (RightOuterJoin a (b, (ma :& b') -> SqlExpr (Value Bool)))

Defined in Database.Esqueleto.Experimental

Methods

toFrom :: RightOuterJoin a (b, (ma :& b') -> SqlExpr (Value Bool)) -> From (ToFromT (RightOuterJoin a (b, (ma :& b') -> SqlExpr (Value Bool))))

(ToFrom a, ToFromT a ~ a', ToFrom b, ToFromT b ~ b', ToMaybe b', mb ~ ToMaybeT b') => ToFrom (LeftOuterJoin a (b, (a' :& mb) -> SqlExpr (Value Bool)))

Defined in Database.Esqueleto.Experimental

Methods

toFrom :: LeftOuterJoin a (b, (a' :& mb) -> SqlExpr (Value Bool)) -> From (ToFromT (LeftOuterJoin a (b, (a' :& mb) -> SqlExpr (Value Bool))))

(ToFrom a, ToFromT a ~ a', ToFrom b, ToFromT b ~ b') => ToFrom (InnerJoin a (b, (a' :& b') -> SqlExpr (Value Bool)))

Defined in Database.Esqueleto.Experimental

Methods

toFrom :: InnerJoin a (b, (a' :& b') -> SqlExpr (Value Bool)) -> From (ToFromT (InnerJoin a (b, (a' :& b') -> SqlExpr (Value Bool))))

Internals

class ToFrom a where

Methods

toFrom :: a -> From (ToFromT a)

Instances

ToFrom (From a)

Defined in Database.Esqueleto.Experimental

Methods

toFrom :: From a -> From (ToFromT (From a))

(SqlSelect a' r, SqlSelect a'' r', ToAlias a, a' ~ ToAliasT a, ToAliasReference a', ToAliasReferenceT a' ~ a'') => ToFrom (SqlSetOperation a)

Defined in Database.Esqueleto.Experimental

Methods

toFrom :: SqlSetOperation a -> From (ToFromT (SqlSetOperation a))

(ToFrom a, ToFromT a ~ a', ToFrom b, ToFromT b ~ b', ToMaybe a', ma ~ ToMaybeT a', ToMaybe b', mb ~ ToMaybeT b') => ToFrom (FullOuterJoin a (b, (ma :& mb) -> SqlExpr (Value Bool)))

Defined in Database.Esqueleto.Experimental

Methods

toFrom :: FullOuterJoin a (b, (ma :& mb) -> SqlExpr (Value Bool)) -> From (ToFromT (FullOuterJoin a (b, (ma :& mb) -> SqlExpr (Value Bool))))

ToFrom (FullOuterJoin a b)

Defined in Database.Esqueleto.Experimental

Methods

toFrom :: FullOuterJoin a b -> From (ToFromT (FullOuterJoin a b))

(ToFrom a, ToFromT a ~ a', ToFrom b, ToFromT b ~ b', ToMaybe a', ma ~ ToMaybeT a') => ToFrom (RightOuterJoin a (b, (ma :& b') -> SqlExpr (Value Bool)))

Defined in Database.Esqueleto.Experimental

Methods

toFrom :: RightOuterJoin a (b, (ma :& b') -> SqlExpr (Value Bool)) -> From (ToFromT (RightOuterJoin a (b, (ma :& b') -> SqlExpr (Value Bool))))

ToFrom (RightOuterJoin a b)

Defined in Database.Esqueleto.Experimental

Methods

toFrom :: RightOuterJoin a b -> From (ToFromT (RightOuterJoin a b))

(ToFrom a, ToFromT a ~ a', ToFrom b, ToFromT b ~ b', ToMaybe b', mb ~ ToMaybeT b') => ToFrom (LeftOuterJoin a (b, (a' :& mb) -> SqlExpr (Value Bool)))

Defined in Database.Esqueleto.Experimental

Methods

toFrom :: LeftOuterJoin a (b, (a' :& mb) -> SqlExpr (Value Bool)) -> From (ToFromT (LeftOuterJoin a (b, (a' :& mb) -> SqlExpr (Value Bool))))

ToFrom (LeftOuterJoin a b)

Defined in Database.Esqueleto.Experimental

Methods

toFrom :: LeftOuterJoin a b -> From (ToFromT (LeftOuterJoin a b))

(ToFrom a, ToFrom b) => ToFrom (CrossJoin a b)

Defined in Database.Esqueleto.Experimental

Methods

toFrom :: CrossJoin a b -> From (ToFromT (CrossJoin a b))

(ToFrom a, ToFromT a ~ a', ToFrom b, ToFromT b ~ b') => ToFrom (InnerJoin a (b, (a' :& b') -> SqlExpr (Value Bool)))

Defined in Database.Esqueleto.Experimental

Methods

toFrom :: InnerJoin a (b, (a' :& b') -> SqlExpr (Value Bool)) -> From (ToFromT (InnerJoin a (b, (a' :& b') -> SqlExpr (Value Bool))))

ToFrom (InnerJoin a b)

Defined in Database.Esqueleto.Experimental

Methods

toFrom :: InnerJoin a b -> From (ToFromT (InnerJoin a b))

type family ToFromT a where ...

Equations

ToFromT (From a) = a

ToFromT (SqlSetOperation a) = ToAliasReferenceT (ToAliasT a)

ToFromT (LeftOuterJoin a (b, c -> SqlExpr (Value Bool))) = c

ToFromT (FullOuterJoin a (b, c -> SqlExpr (Value Bool))) = c

ToFromT (RightOuterJoin a (b, c -> SqlExpr (Value Bool))) = c

ToFromT (InnerJoin a (b, c -> SqlExpr (Value Bool))) = c

ToFromT (CrossJoin a b) = ToFromT a :& ToFromT b

ToFromT (InnerJoin a b) = TypeError (JoinErrorMsg "InnerJoin")

ToFromT (LeftOuterJoin a b) = TypeError (JoinErrorMsg "LeftOuterJoin")

ToFromT (RightOuterJoin a b) = TypeError (JoinErrorMsg "RightOuterJoin")

ToFromT (FullOuterJoin a b) = TypeError (JoinErrorMsg "FullOuterJoin")

class ToMaybe a where

Methods

toMaybe :: a -> ToMaybeT a

Instances

ToMaybe (SqlExpr (Maybe a))

Defined in Database.Esqueleto.Experimental

Methods

toMaybe :: SqlExpr (Maybe a) -> ToMaybeT (SqlExpr (Maybe a))

ToMaybe (SqlExpr (Entity a))

Defined in Database.Esqueleto.Experimental

Methods

toMaybe :: SqlExpr (Entity a) -> ToMaybeT (SqlExpr (Entity a))

ToMaybe (SqlExpr (Value a))

Defined in Database.Esqueleto.Experimental

Methods

toMaybe :: SqlExpr (Value a) -> ToMaybeT (SqlExpr (Value a))

(ToMaybe a, ToMaybe b) => ToMaybe (a, b)

Defined in Database.Esqueleto.Experimental

Methods

toMaybe :: (a, b) -> ToMaybeT (a, b)

(ToMaybe a, ToMaybe b) => ToMaybe (a :& b)

Defined in Database.Esqueleto.Experimental

Methods

toMaybe :: (a :& b) -> ToMaybeT (a :& b)

(ToMaybe a, ToMaybe b, ToMaybe c) => ToMaybe (a, b, c)

Defined in Database.Esqueleto.Experimental

Methods

toMaybe :: (a, b, c) -> ToMaybeT (a, b, c)

(ToMaybe a, ToMaybe b, ToMaybe c, ToMaybe d) => ToMaybe (a, b, c, d)

Defined in Database.Esqueleto.Experimental

Methods

toMaybe :: (a, b, c, d) -> ToMaybeT (a, b, c, d)

(ToMaybe a, ToMaybe b, ToMaybe c, ToMaybe d, ToMaybe e) => ToMaybe (a, b, c, d, e)

Defined in Database.Esqueleto.Experimental

Methods

toMaybe :: (a, b, c, d, e) -> ToMaybeT (a, b, c, d, e)

(ToMaybe a, ToMaybe b, ToMaybe c, ToMaybe d, ToMaybe e, ToMaybe f) => ToMaybe (a, b, c, d, e, f)

Defined in Database.Esqueleto.Experimental

Methods

toMaybe :: (a, b, c, d, e, f) -> ToMaybeT (a, b, c, d, e, f)

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

Defined in Database.Esqueleto.Experimental

Methods

toMaybe :: (a, b, c, d, e, f, g) -> ToMaybeT (a, b, c, d, e, f, g)

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

Defined in Database.Esqueleto.Experimental

Methods

toMaybe :: (a, b, c, d, e, f, g, h) -> ToMaybeT (a, b, c, d, e, f, g, h)

type family ToMaybeT a where ...

Equations

ToMaybeT (SqlExpr (Maybe a)) = SqlExpr (Maybe a)

ToMaybeT (SqlExpr (Entity a)) = SqlExpr (Maybe (Entity a))

ToMaybeT (SqlExpr (Value a)) = SqlExpr (Value (Maybe (Nullable a)))

ToMaybeT (a :& b) = ToMaybeT a :& ToMaybeT b

ToMaybeT (a, b) = (ToMaybeT a, ToMaybeT b)

ToMaybeT (a, b, c) = (ToMaybeT a, ToMaybeT b, ToMaybeT c)

ToMaybeT (a, b, c, d) = (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d)

ToMaybeT (a, b, c, d, e) = (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e)

ToMaybeT (a, b, c, d, e, f) = (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e, ToMaybeT f)

ToMaybeT (a, b, c, d, e, f, g) = (ToMaybeT a, ToMaybeT b, ToMaybeT c, ToMaybeT d, ToMaybeT e, ToMaybeT f, ToMaybeT g)

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

class ToAlias a where

Methods

toAlias :: a -> SqlQuery (ToAliasT a)

Instances

ToAlias (SqlExpr (Entity a))

Defined in Database.Esqueleto.Experimental

Methods

toAlias :: SqlExpr (Entity a) -> SqlQuery (ToAliasT (SqlExpr (Entity a)))

ToAlias (SqlExpr (Value a))

Defined in Database.Esqueleto.Experimental

Methods

toAlias :: SqlExpr (Value a) -> SqlQuery (ToAliasT (SqlExpr (Value a)))

(ToAlias a, ToAlias b) => ToAlias (a, b)

Defined in Database.Esqueleto.Experimental

Methods

toAlias :: (a, b) -> SqlQuery (ToAliasT (a, b))

(ToAlias a, ToAlias b, ToAlias c) => ToAlias (a, b, c)

Defined in Database.Esqueleto.Experimental

Methods

toAlias :: (a, b, c) -> SqlQuery (ToAliasT (a, b, c))

(ToAlias a, ToAlias b, ToAlias c, ToAlias d) => ToAlias (a, b, c, d)

Defined in Database.Esqueleto.Experimental

Methods

toAlias :: (a, b, c, d) -> SqlQuery (ToAliasT (a, b, c, d))

(ToAlias a, ToAlias b, ToAlias c, ToAlias d, ToAlias e) => ToAlias (a, b, c, d, e)

Defined in Database.Esqueleto.Experimental

Methods

toAlias :: (a, b, c, d, e) -> SqlQuery (ToAliasT (a, b, c, d, e))

(ToAlias a, ToAlias b, ToAlias c, ToAlias d, ToAlias e, ToAlias f) => ToAlias (a, b, c, d, e, f)

Defined in Database.Esqueleto.Experimental

Methods

toAlias :: (a, b, c, d, e, f) -> SqlQuery (ToAliasT (a, b, c, d, e, f))

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

Defined in Database.Esqueleto.Experimental

Methods

toAlias :: (a, b, c, d, e, f, g) -> SqlQuery (ToAliasT (a, b, c, d, e, f, g))

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

Defined in Database.Esqueleto.Experimental

Methods

toAlias :: (a, b, c, d, e, f, g, h) -> SqlQuery (ToAliasT (a, b, c, d, e, f, g, h))

type family ToAliasT a where ...

Equations

ToAliasT (SqlExpr (Value a)) = SqlExpr (Value a)

ToAliasT (SqlExpr (Entity a)) = SqlExpr (Entity a)

ToAliasT (a, b) = (ToAliasT a, ToAliasT b)

ToAliasT (a, b, c) = (ToAliasT a, ToAliasT b, ToAliasT c)

ToAliasT (a, b, c, d) = (ToAliasT a, ToAliasT b, ToAliasT c, ToAliasT d)

ToAliasT (a, b, c, d, e) = (ToAliasT a, ToAliasT b, ToAliasT c, ToAliasT d, ToAliasT e)

ToAliasT (a, b, c, d, e, f) = (ToAliasT a, ToAliasT b, ToAliasT c, ToAliasT d, ToAliasT e, ToAliasT f)

ToAliasT (a, b, c, d, e, f, g) = (ToAliasT a, ToAliasT b, ToAliasT c, ToAliasT d, ToAliasT e, ToAliasT f, ToAliasT g)

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

class ToAliasReference a where

Methods

toAliasReference :: Ident -> a -> SqlQuery (ToAliasReferenceT a)

Instances

ToAliasReference (SqlExpr (Entity a))

Defined in Database.Esqueleto.Experimental

Methods

toAliasReference :: Ident -> SqlExpr (Entity a) -> SqlQuery (ToAliasReferenceT (SqlExpr (Entity a)))

ToAliasReference (SqlExpr (Value a))

Defined in Database.Esqueleto.Experimental

Methods

toAliasReference :: Ident -> SqlExpr (Value a) -> SqlQuery (ToAliasReferenceT (SqlExpr (Value a)))

(ToAliasReference a, ToAliasReference b) => ToAliasReference (a, b)

Defined in Database.Esqueleto.Experimental

Methods

toAliasReference :: Ident -> (a, b) -> SqlQuery (ToAliasReferenceT (a, b))

(ToAliasReference a, ToAliasReference b, ToAliasReference c) => ToAliasReference (a, b, c)

Defined in Database.Esqueleto.Experimental

Methods

toAliasReference :: Ident -> (a, b, c) -> SqlQuery (ToAliasReferenceT (a, b, c))

(ToAliasReference a, ToAliasReference b, ToAliasReference c, ToAliasReference d) => ToAliasReference (a, b, c, d)

Defined in Database.Esqueleto.Experimental

Methods

toAliasReference :: Ident -> (a, b, c, d) -> SqlQuery (ToAliasReferenceT (a, b, c, d))

(ToAliasReference a, ToAliasReference b, ToAliasReference c, ToAliasReference d, ToAliasReference e) => ToAliasReference (a, b, c, d, e)

Defined in Database.Esqueleto.Experimental

Methods

toAliasReference :: Ident -> (a, b, c, d, e) -> SqlQuery (ToAliasReferenceT (a, b, c, d, e))

(ToAliasReference a, ToAliasReference b, ToAliasReference c, ToAliasReference d, ToAliasReference e, ToAliasReference f) => ToAliasReference (a, b, c, d, e, f)

Defined in Database.Esqueleto.Experimental

Methods

toAliasReference :: Ident -> (a, b, c, d, e, f) -> SqlQuery (ToAliasReferenceT (a, b, c, d, e, f))

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

Defined in Database.Esqueleto.Experimental

Methods

toAliasReference :: Ident -> (a, b, c, d, e, f, g) -> SqlQuery (ToAliasReferenceT (a, b, c, d, e, f, g))

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

Defined in Database.Esqueleto.Experimental

Methods

toAliasReference :: Ident -> (a, b, c, d, e, f, g, h) -> SqlQuery (ToAliasReferenceT (a, b, c, d, e, f, g, h))

type family ToAliasReferenceT a where ...

Equations

ToAliasReferenceT (SqlExpr (Value a)) = SqlExpr (Value a)

ToAliasReferenceT (SqlExpr (Entity a)) = SqlExpr (Entity a)

ToAliasReferenceT (a, b) = (ToAliasReferenceT a, ToAliasReferenceT b)

ToAliasReferenceT (a, b, c) = (ToAliasReferenceT a, ToAliasReferenceT b, ToAliasReferenceT c)

ToAliasReferenceT (a, b, c, d) = (ToAliasReferenceT a, ToAliasReferenceT b, ToAliasReferenceT c, ToAliasReferenceT d)

ToAliasReferenceT (a, b, c, d, e) = (ToAliasReferenceT a, ToAliasReferenceT b, ToAliasReferenceT c, ToAliasReferenceT d, ToAliasReferenceT e)

ToAliasReferenceT (a, b, c, d, e, f) = (ToAliasReferenceT a, ToAliasReferenceT b, ToAliasReferenceT c, ToAliasReferenceT d, ToAliasReferenceT e, ToAliasReferenceT f)

ToAliasReferenceT (a, b, c, d, e, f, g) = (ToAliasReferenceT a, ToAliasReferenceT b, ToAliasReferenceT c, ToAliasReferenceT d, ToAliasReferenceT e, ToAliasReferenceT f, ToAliasReferenceT g)

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