Database.Esqueleto

Warning: This module will switch over to the Experimental syntax in an upcoming major version release. Please migrate to the Database.Esqueleto.Legacy module to continue using the old syntax, or translate to the new and improved syntax in Database.Esqueleto.Experimental.

The esqueleto EDSL (embedded domain specific language). This module replaces Database.Persist, so instead of importing that module you should just import this one:

-- For a module using just esqueleto.
import Database.Esqueleto

If you need to use persistent's default support for queries as well, either import it qualified:

-- For a module that mostly uses esqueleto.
import Database.Esqueleto
import qualified Database.Persist as P

or import esqueleto itself qualified:

-- For a module that uses esqueleto just on some queries.
import Database.Persist
import qualified Database.Esqueleto as E

Other than identifier name clashes, esqueleto does not conflict with persistent in any way.

Note that the facilities for JOIN have been significantly improved in the Database.Esqueleto.Experimental module. The definition of from and on in this module will be replaced with those at the 4.0.0.0 version, so you are encouraged to migrate to the new method.

This module has an attached WARNING message indicating that the Experimental syntax will become the default. If you want to continue using the old syntax, please refer to Database.Esqueleto.Legacy as a drop-in replacement.

Setup

If you're already using persistent, then you're ready to use esqueleto, no further setup is needed. If you're just starting a new project and would like to use esqueleto, take a look at persistent's book first (http://www.yesodweb.com/book/persistent) to learn how to define your schema.

Introduction

The main goals of esqueleto are to:

• Be easily translatable to SQL. When you take a look at a esqueleto query, you should be able to know exactly how the SQL query will end up. (As opposed to being a relational algebra EDSL such as HaskellDB, which is non-trivial to translate into SQL.)
• Support the most widely used SQL features. We'd like you to be able to use esqueleto for all of your queries, no exceptions. Send a pull request or open an issue on our project page (https://github.com/prowdsponsor/esqueleto) if there's anything missing that you'd like to see.
• Be as type-safe as possible. We strive to provide as many type checks as possible. If you get bitten by some invalid code that type-checks, please open an issue on our project page so we can take a look.

However, it is not a goal to be able to write portable SQL. We do not try to hide the differences between DBMSs from you, and esqueleto code that works for one database may not work on another. This is a compromise we have to make in order to give you as much control over the raw SQL as possible without losing too much convenience. This also means that you may type-check a query that doesn't work on your DBMS.

Getting started

We like clean, easy-to-read EDSLs. However, in order to achieve this goal we've used a lot of type hackery, leading to some hard-to-read type signatures. On this section, we'll try to build some intuition about the syntax.

For the following examples, we'll use this example schema:

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

Most of esqueleto was created with SELECT statements in mind, not only because they're the most common but also because they're the most complex kind of statement. The most simple kind of SELECT would be:

SELECT *
FROM Person

In esqueleto, we may write the same query above as:

do people <- select $
             from $ \person -> do
             return person
   liftIO $ mapM_ (putStrLn . personName . entityVal) people

The expression above has type SqlPersist m (), while people has type [Entity Person]. The query above will be translated into exactly the same query we wrote manually, but instead of SELECT * it will list all entity fields (using * is not robust). Note that esqueleto knows that we want an Entity Person just because of the personName that we're printing later.

However, most of the time we need to filter our queries using WHERE. For example:

SELECT *
FROM Person
WHERE Person.name = "John"

In esqueleto, we may write the same query above as:

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

Although esqueleto's code is a bit more noisy, it's has almost the same structure (save from the return). The (^.) operator is used to project a field from an entity. The field name is the same one generated by persistent's Template Haskell functions. We use val to lift a constant Haskell value into the SQL query.

Another example would be:

SELECT *
FROM Person
WHERE Person.age >= 18

In esqueleto, we may write the same query above as:

select $
from $ \p -> do
where_ (p ^. PersonAge >=. just (val 18))
return p

Since age is an optional Person field, we use just to lift val 18 :: SqlExpr (Value Int) into just (val 18) :: SqlExpr (Value (Maybe Int)).

Implicit joins are represented by tuples. For example, to get the list of all blog posts and their authors, we could write:

SELECT BlogPost.*, Person.*
FROM BlogPost, Person
WHERE BlogPost.authorId = Person.id
ORDER BY BlogPost.title ASC

In esqueleto, we may write the same query above as:

select $
from $ \(b, p) -> do
where_ (b ^. BlogPostAuthorId ==. p ^. PersonId)
orderBy [asc (b ^. BlogPostTitle)]
return (b, p)

However, you may want your results to include people who don't have any blog posts as well using a LEFT OUTER JOIN:

SELECT Person.*, BlogPost.*
FROM Person LEFT OUTER JOIN BlogPost
ON Person.id = BlogPost.authorId
ORDER BY Person.name ASC, BlogPost.title ASC

In esqueleto, we may write the same query above as:

select $
from $ \(p `LeftOuterJoin` mb) -> do
on (just (p ^. PersonId) ==. mb ?. BlogPostAuthorId)
orderBy [asc (p ^. PersonName), asc (mb ?. BlogPostTitle)]
return (p, mb)

On a LEFT OUTER JOIN the entity on the right hand side may not exist (i.e. there may be a Person without any BlogPosts), so while p :: SqlExpr (Entity Person), we have mb :: SqlExpr (Maybe (Entity BlogPost)). The whole expression above has type SqlPersist m [(Entity Person, Maybe (Entity BlogPost))]. Instead of using (^.), we used (?.) to project a field from a Maybe (Entity a).

We are by no means limited to joins of two tables, nor by joins of different tables. For example, we may want a list of the Follow entity:

SELECT P1.*, Follow.*, P2.*
FROM Person AS P1
INNER JOIN Follow ON P1.id = Follow.follower
INNER JOIN Person AS P2 ON P2.id = Follow.followed

In esqueleto, we may write the same query above as:

select $
from $ \(p1 `InnerJoin` f `InnerJoin` p2) -> do
on (p1 ^. PersonId ==. f ^. FollowFollower)
on (p2 ^. PersonId ==. f ^. FollowFollowed)
return (p1, f, p2)

We also currently support UPDATE and DELETE statements. For example:

do update $ \p -> do
     set p [ PersonName =. val "João" ]
     where_ (p ^. PersonName ==. val "Joao")
   delete $
     from $ \p -> do
     where_ (p ^. PersonAge <. just (val 14))

The results of queries can also be used for insertions. In SQL, we might write the following, inserting a new blog post for every user:

INSERT INTO BlogPost
SELECT ('Group Blog Post', id)
FROM Person

In esqueleto, we may write the same query above as:

 insertSelect $ from $ \p->
 return $ BlogPost <# "Group Blog Post" <&> (p ^. PersonId)

Individual insertions can be performed through Persistent's insert function, reexported for convenience.

esqueleto's Language

where_ :: SqlExpr (Value Bool) -> SqlQuery ()

WHERE clause: restrict the query's result.

on :: SqlExpr (Value Bool) -> SqlQuery ()

An ON clause, useful to describe how two tables are related. Cross joins and tuple-joins do not need an on clause, but InnerJoin and the various outer joins do.

Database.Esqueleto.Experimental in version 4.0.0.0 of the library. The Experimental module has a dramatically improved means for introducing tables and entities that provides more power and less potential for runtime errors.

If you don't include an on clause (or include too many!) then a runtime exception will be thrown.

As an example, consider this simple join:

select $
from $ \(foo `InnerJoin` bar) -> do
  on (foo ^. FooId ==. bar ^. BarFooId)
  ...

We need to specify the clause for joining the two columns together. If we had this:

select $
from $ \(foo `CrossJoin` bar) -> do
  ...

Then we can safely omit the on clause, because the cross join will make pairs of all records possible.

You can do multiple on clauses in a query. This query joins three tables, and has two on clauses:

select $
from $ \(foo `InnerJoin` bar `InnerJoin` baz) -> do
  on (baz ^. BazId ==. bar ^. BarBazId)
  on (foo ^. FooId ==. bar ^. BarFooId)
  ...

Old versions of esqueleto required that you provide the on clauses in reverse order. This restriction has been lifted - you can now provide on clauses in any order, and the SQL should work itself out. The above query is now totally equivalent to this:

select $
from $ \(foo `InnerJoin` bar `InnerJoin` baz) -> do
  on (foo ^. FooId ==. bar ^. BarFooId)
  on (baz ^. BazId ==. bar ^. BarBazId)
  ...

groupBy :: ToSomeValues a => a -> SqlQuery ()

GROUP BY clause. You can enclose multiple columns in a tuple.

select $ from \(foo `InnerJoin` bar) -> do
  on (foo ^. FooBarId ==. bar ^. BarId)
  groupBy (bar ^. BarId, bar ^. BarName)
  return (bar ^. BarId, bar ^. BarName, countRows)

With groupBy you can sort by aggregate functions, like so (we used let to restrict the more general countRows to SqlSqlExpr (Value Int) to avoid ambiguity---the second use of countRows has its type restricted by the :: Int below):

r <- select $ from \(foo `InnerJoin` bar) -> do
  on (foo ^. FooBarId ==. bar ^. BarId)
  groupBy $ bar ^. BarName
  let countRows' = countRows
  orderBy [asc countRows']
  return (bar ^. BarName, countRows')
forM_ r $ \(Value name, Value count) -> do
  print name
  print (count :: Int)

Need more columns?

The ToSomeValues class is defined for SqlExpr and tuples of SqlExprs. We only have definitions for up to 8 elements in a tuple right now, so it's possible that you may need to have more than 8 elements.

For example, consider a query with a groupBy call like this:

groupBy (e0, e1, e2, e3, e4, e5, e6, e7)

This is the biggest you can get with a single tuple. However, you can easily nest the tuples to add more:

groupBy ((e0, e1, e2, e3, e4, e5, e6, e7), e8, e9)

orderBy :: [SqlExpr OrderBy] -> SqlQuery ()

ORDER BY clause. See also asc and desc.

Multiple calls to orderBy get concatenated on the final query, including distinctOnOrderBy.

rand :: SqlExpr OrderBy

Deprecated: Since 2.6.0: rand ordering function is not uniform across all databases! To avoid accidental partiality it will be removed in the next major version.

ORDER BY random() clause.

Since: 1.3.10

asc :: PersistField a => SqlExpr (Value a) -> SqlExpr OrderBy

Ascending order of this field or SqlExpression.

desc :: PersistField a => SqlExpr (Value a) -> SqlExpr OrderBy

Descending order of this field or SqlExpression.

limit :: Int64 -> SqlQuery ()

LIMIT. Limit the number of returned rows.

offset :: Int64 -> SqlQuery ()

OFFSET. Usually used with limit.

distinct :: SqlQuery a -> SqlQuery a

DISTINCT. Change the current SELECT into SELECT DISTINCT. For example:

select $ distinct $
  from \foo -> do
  ...

Note that this also has the same effect:

select $
  from \foo -> do
  distinct (return ())
  ...

Since: 2.2.4

distinctOn :: [SqlExpr DistinctOn] -> SqlQuery a -> SqlQuery a

DISTINCT ON. Change the current SELECT into SELECT DISTINCT ON (SqlExpressions). For example:

select $
  from \foo ->
  distinctOn [don (foo ^. FooName), don (foo ^. FooState)] $ do
  ...

You can also chain different calls to distinctOn. The above is equivalent to:

select $
  from \foo ->
  distinctOn [don (foo ^. FooName)] $
  distinctOn [don (foo ^. FooState)] $ do
  ...

Each call to distinctOn adds more SqlExpressions. Calls to distinctOn override any calls to distinct.

Note that PostgreSQL requires the SqlExpressions on DISTINCT ON to be the first ones to appear on a ORDER BY. This is not managed automatically by esqueleto, keeping its spirit of trying to be close to raw SQL.

Supported by PostgreSQL only.

Since: 2.2.4

don :: SqlExpr (Value a) -> SqlExpr DistinctOn

Erase an SqlExpression's type so that it's suitable to be used by distinctOn.

Since: 2.2.4

distinctOnOrderBy :: [SqlExpr OrderBy] -> SqlQuery a -> SqlQuery a

A convenience function that calls both distinctOn and orderBy. In other words,

distinctOnOrderBy [asc foo, desc bar, desc quux] $ do
  ...

is the same as:

distinctOn [don foo, don  bar, don  quux] $ do
  orderBy  [asc foo, desc bar, desc quux]
  ...

Since: 2.2.4

having :: SqlExpr (Value Bool) -> SqlQuery ()

HAVING.

Since: 1.2.2

locking :: LockingKind -> SqlQuery ()

Add a locking clause to the query. Please read LockingKind documentation and your RDBMS manual. Unsafe since not all locking clauses are implemented for every RDBMS

If multiple calls to locking are made on the same query, the last one is used.

Since: 2.2.7

sub_select :: PersistField a => SqlQuery (SqlExpr (Value a)) -> SqlExpr (Value a)

Deprecated: sub_select sub_select is an unsafe function to use. If used with a SqlQuery that returns 0 results, then it may return NULL despite not mentioning Maybe in the return type. If it returns more than 1 result, then it will throw a SQL error. Instead, consider using one of the following alternatives: - subSelect: attaches a LIMIT 1 and the Maybe return type, totally safe. - subSelectMaybe: Attaches a LIMIT 1, useful for a query that already has a Maybe in the return type. - subSelectCount: Performs a count of the query - this is always safe. - subSelectUnsafe: Performs no checks or guarantees. Safe to use with countRows and friends.

Execute a subquery SELECT in an SqlExpression. Returns a simple value so should be used only when the SELECT query is guaranteed to return just one row.

Deprecated in 3.2.0.

(^.) :: forall typ val. (PersistEntity val, PersistField typ) => SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ) infixl 9

Project a field of an entity.

(?.) :: (PersistEntity val, PersistField typ) => SqlExpr (Maybe (Entity val)) -> EntityField val typ -> SqlExpr (Value (Maybe typ))

Project a field of an entity that may be null.

val :: PersistField typ => typ -> SqlExpr (Value typ)

Lift a constant value from Haskell-land to the query.

isNothing :: PersistField typ => SqlExpr (Value (Maybe typ)) -> SqlExpr (Value Bool)

IS NULL comparison.

For IS NOT NULL, you can negate this with not_, as in not_ (isNothing (person ^. PersonAge))

Warning: Persistent and Esqueleto have different behavior for != Nothing:

	Haskell	SQL
Persistent	!=. Nothing	IS NOT NULL
Esqueleto	!=. Nothing	!= NULL

In SQL, = NULL and != NULL return NULL instead of true or false. For this reason, you very likely do not want to use !=. Nothing in Esqueleto. You may find these hlint rules helpful to enforce this:

- error: {lhs: v Database.Esqueleto.==. Database.Esqueleto.nothing, rhs: Database.Esqueleto.isNothing v, name: Use Esqueleto's isNothing}
- error: {lhs: v Database.Esqueleto.==. Database.Esqueleto.val Nothing, rhs: Database.Esqueleto.isNothing v, name: Use Esqueleto's isNothing}
- error: {lhs: v Database.Esqueleto.!=. Database.Esqueleto.nothing, rhs: not_ (Database.Esqueleto.isNothing v), name: Use Esqueleto's not isNothing}
- error: {lhs: v Database.Esqueleto.!=. Database.Esqueleto.val Nothing, rhs: not_ (Database.Esqueleto.isNothing v), name: Use Esqueleto's not isNothing}

just :: SqlExpr (Value typ) -> SqlExpr (Value (Maybe typ))

Analogous to Just, promotes a value of type typ into one of type Maybe typ. It should hold that val . Just === just . val.

nothing :: SqlExpr (Value (Maybe typ))

NULL value.

joinV :: SqlExpr (Value (Maybe (Maybe typ))) -> SqlExpr (Value (Maybe typ))

Join nested Maybes in a Value into one. This is useful when calling aggregate functions on nullable fields.

withNonNull :: PersistField typ => SqlExpr (Value (Maybe typ)) -> (SqlExpr (Value typ) -> SqlQuery a) -> SqlQuery a

Project an SqlExpression that may be null, guarding against null cases.

countRows :: Num a => SqlExpr (Value a)

COUNT(*) value.

count :: Num a => SqlExpr (Value typ) -> SqlExpr (Value a)

COUNT.

countDistinct :: Num a => SqlExpr (Value typ) -> SqlExpr (Value a)

COUNT(DISTINCT x).

Since: 2.4.1

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

(==.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool) infix 4

(>=.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool) infix 4

(>.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool) infix 4

(<=.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool) infix 4

(<.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool) infix 4

(!=.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool) infix 4

(&&.) :: SqlExpr (Value Bool) -> SqlExpr (Value Bool) -> SqlExpr (Value Bool) infixr 3

(||.) :: SqlExpr (Value Bool) -> SqlExpr (Value Bool) -> SqlExpr (Value Bool) infixr 2

between :: PersistField a => SqlExpr (Value a) -> (SqlExpr (Value a), SqlExpr (Value a)) -> SqlExpr (Value Bool)

BETWEEN.

@since: 3.1.0

(+.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a) infixl 6

(-.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a) infixl 6

(/.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a) infixl 7

(*.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a) infixl 7

random_ :: (PersistField a, Num a) => SqlExpr (Value a)

Deprecated: Since 2.6.0: random_ is not uniform across all databases! Please use a specific one such as random_, random_, or random_

round_ :: (PersistField a, Num a, PersistField b, Num b) => SqlExpr (Value a) -> SqlExpr (Value b)

ceiling_ :: (PersistField a, Num a, PersistField b, Num b) => SqlExpr (Value a) -> SqlExpr (Value b)

floor_ :: (PersistField a, Num a, PersistField b, Num b) => SqlExpr (Value a) -> SqlExpr (Value b)

min_ :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value (Maybe a))

max_ :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value (Maybe a))

sum_ :: (PersistField a, PersistField b) => SqlExpr (Value a) -> SqlExpr (Value (Maybe b))

avg_ :: (PersistField a, PersistField b) => SqlExpr (Value a) -> SqlExpr (Value (Maybe b))

castNum :: (Num a, Num b) => SqlExpr (Value a) -> SqlExpr (Value b)

Allow a number of one type to be used as one of another type via an implicit cast. An explicit cast is not made, this function changes only the types on the Haskell side.

Caveat: Trying to use castNum from Double to Int will not result in an integer, the original fractional number will still be used! Use round_, ceiling_ or floor_ instead.

Safety: This operation is mostly safe due to the Num constraint between the types and the fact that RDBMSs usually allow numbers of different types to be used interchangeably. However, there may still be issues with the query not being accepted by the RDBMS or persistent not being able to parse it.

Since: 2.2.9

castNumM :: (Num a, Num b) => SqlExpr (Value (Maybe a)) -> SqlExpr (Value (Maybe b))

Same as castNum, but for nullable values.

Since: 2.2.9

coalesce :: PersistField a => [SqlExpr (Value (Maybe a))] -> SqlExpr (Value (Maybe a))

COALESCE function. Evaluates the arguments in order and returns the value of the first non-NULL SqlExpression, or NULL (Nothing) otherwise. Some RDBMSs (such as SQLite) require at least two arguments; please refer to the appropriate documentation.

Since: 1.4.3

coalesceDefault :: PersistField a => [SqlExpr (Value (Maybe a))] -> SqlExpr (Value a) -> SqlExpr (Value a)

Like coalesce, but takes a non-nullable SqlExpression placed at the end of the SqlExpression list, which guarantees a non-NULL result.

Since: 1.4.3

lower_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

LOWER function.

upper_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

UPPER function. @since 3.3.0

trim_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

TRIM function. @since 3.3.0

ltrim_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

LTRIM function. @since 3.3.0

rtrim_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

RTRIM function. @since 3.3.0

length_ :: (SqlString s, Num a) => SqlExpr (Value s) -> SqlExpr (Value a)

LENGTH function. @since 3.3.0

left_ :: (SqlString s, Num a) => (SqlExpr (Value s), SqlExpr (Value a)) -> SqlExpr (Value s)

LEFT function. @since 3.3.0

right_ :: (SqlString s, Num a) => (SqlExpr (Value s), SqlExpr (Value a)) -> SqlExpr (Value s)

RIGHT function. @since 3.3.0

like :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s) -> SqlExpr (Value Bool) infixr 2

LIKE operator.

ilike :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s) -> SqlExpr (Value Bool) infixr 2

ILIKE operator (case-insensitive LIKE).

Supported by PostgreSQL only.

Since: 2.2.3

(%) :: SqlString s => SqlExpr (Value s)

The string %. May be useful while using like and concatenation (concat_ or ++., depending on your database). Note that you always have to type the parenthesis, for example:

name `like` (%) ++. val "John" ++. (%)

concat_ :: SqlString s => [SqlExpr (Value s)] -> SqlExpr (Value s)

The CONCAT function with a variable number of parameters. Supported by MySQL and PostgreSQL.

(++.) :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s) -> SqlExpr (Value s) infixr 5

The || string concatenation operator (named after Haskell's ++ in order to avoid naming clash with ||.). Supported by SQLite and PostgreSQL.

castString :: (SqlString s, SqlString r) => SqlExpr (Value s) -> SqlExpr (Value r)

Cast a string type into Text. This function is very useful if you want to use newtypes, or if you want to apply functions such as like to strings of different types.

Safety: This is a slightly unsafe function, especially if you have defined your own instances of SqlString. Also, since Maybe is an instance of SqlString, it's possible to turn a nullable value into a non-nullable one. Avoid using this function if possible.

subList_select :: PersistField a => SqlQuery (SqlExpr (Value a)) -> SqlExpr (ValueList a)

Execute a subquery SELECT in an SqlExpression. Returns a list of values.

valList :: PersistField typ => [typ] -> SqlExpr (ValueList typ)

Lift a list of constant value from Haskell-land to the query.

justList :: SqlExpr (ValueList typ) -> SqlExpr (ValueList (Maybe typ))

Same as just but for ValueList. Most of the time you won't need it, though, because you can use just from inside subList_select or Just from inside valList.

Since: 2.2.12

in_ :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (ValueList typ) -> SqlExpr (Value Bool)

IN operator. For example if you want to select all Persons by a list of IDs:

SELECT *
FROM Person
WHERE Person.id IN (?)

In esqueleto, we may write the same query above as:

select $
from $ \person -> do
where_ $ person ^. PersonId `in_` valList personIds
return person

Where personIds is of type [Key Person].

notIn :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (ValueList typ) -> SqlExpr (Value Bool)

NOT IN operator.

exists :: SqlQuery () -> SqlExpr (Value Bool)

EXISTS operator. For example:

select $
from $ \person -> do
where_ $ exists $
         from $ \post -> do
         where_ (post ^. BlogPostAuthorId ==. person ^. PersonId)
return person

notExists :: SqlQuery () -> SqlExpr (Value Bool)

NOT EXISTS operator.

set :: PersistEntity val => SqlExpr (Entity val) -> [SqlExpr (Entity val) -> SqlExpr Update] -> SqlQuery ()

SET clause used on UPDATEs. Note that while it's not a type error to use this function on a SELECT, it will most certainly result in a runtime error.

(=.) :: (PersistEntity val, PersistField typ) => EntityField val typ -> SqlExpr (Value typ) -> SqlExpr (Entity val) -> SqlExpr Update infixr 3

(+=.) :: (PersistEntity val, PersistField a) => EntityField val a -> SqlExpr (Value a) -> SqlExpr (Entity val) -> SqlExpr Update infixr 3

(-=.) :: (PersistEntity val, PersistField a) => EntityField val a -> SqlExpr (Value a) -> SqlExpr (Entity val) -> SqlExpr Update infixr 3

(*=.) :: (PersistEntity val, PersistField a) => EntityField val a -> SqlExpr (Value a) -> SqlExpr (Entity val) -> SqlExpr Update infixr 3

(/=.) :: (PersistEntity val, PersistField a) => EntityField val a -> SqlExpr (Value a) -> SqlExpr (Entity val) -> SqlExpr Update infixr 3

case_ :: PersistField a => [(SqlExpr (Value Bool), SqlExpr (Value a))] -> SqlExpr (Value a) -> SqlExpr (Value a)

CASE statement. For example:

select $
return $
case_
   [ when_
       (exists $
       from $ \p -> do
       where_ (p ^. PersonName ==. val "Mike"))
     then_
       (sub_select $
       from $ \v -> do
       let sub =
               from $ \c -> do
               where_ (c ^. PersonName ==. val "Mike")
               return (c ^. PersonFavNum)
       where_ (v ^. PersonFavNum >. sub_select sub)
       return $ count (v ^. PersonName) +. val (1 :: Int)) ]
   (else_ $ val (-1))

This query is a bit complicated, but basically it checks if a person named "Mike" exists, and if that person does, run the subquery to find out how many people have a ranking (by Fav Num) higher than "Mike".

NOTE: There are a few things to be aware about this statement.

• This only implements the full CASE statement, it does not implement the "simple" CASE statement.
• At least one when_ and then_ is mandatory otherwise it will emit an error.
• The else_ is also mandatory, unlike the SQL statement in which if the ELSE is omitted it will return a NULL. You can reproduce this via nothing.

Since: 2.1.2

toBaseId :: ToBaseId ent => SqlExpr (Value (Key ent)) -> SqlExpr (Value (Key (BaseEnt ent)))

Convert an entity's key into another entity's.

This function is to be used when you change an entity's Id to be that of another entity. For example:

Bar
  barNum Int
Foo
  bar BarId
  fooNum Int
  Primary bar

In this example, Bar is said to be the BaseEnt(ity), and Foo the child. To model this in Esqueleto, declare:

instance ToBaseId Foo where
  type BaseEnt Foo = Bar
  toBaseIdWitness barId = FooKey barId

Now you're able to write queries such as:

select $
from $ (bar `InnerJoin` foo) -> do
on (toBaseId (foo ^. FooId) ==. bar ^. BarId)
return (bar, foo)

Note: this function may be unsafe to use in conditions not like the one of the example above.

Since: 2.4.3

subSelect :: PersistField a => SqlQuery (SqlExpr (Value a)) -> SqlExpr (Value (Maybe a))

Execute a subquery SELECT in a SqlExpr. The query passed to this function will only return a single result - it has a LIMIT 1 passed in to the query to make it safe, and the return type is Maybe to indicate that the subquery might result in 0 rows.

If you find yourself writing joinV . subSelect, then consider using subSelectMaybe.

If you're performing a countRows, then you can use subSelectCount which is safe.

If you know that the subquery will always return exactly one row (eg a foreign key constraint guarantees that you'll get exactly one row), then consider subSelectUnsafe, along with a comment explaining why it is safe.

Since: 3.2.0

subSelectMaybe :: PersistField a => SqlQuery (SqlExpr (Value (Maybe a))) -> SqlExpr (Value (Maybe a))

Execute a subquery SELECT in a SqlExpr. This function is a shorthand for the common joinV . subSelect idiom, where you are calling subSelect on an expression that would be Maybe already.

As an example, you would use this function when calling sum_ or max_, which have Maybe in the result type (for a 0 row query).

Since: 3.2.0

subSelectCount :: (Num a, PersistField a) => SqlQuery ignored -> SqlExpr (Value a)

Performs a COUNT of the given query in a subSelect manner. This is always guaranteed to return a result value, and is completely safe.

Since: 3.2.0

subSelectForeign

Arguments

:: (BackendCompatible SqlBackend (PersistEntityBackend val1), PersistEntity val1, PersistEntity val2, PersistField a)

=> SqlExpr (Entity val2)

An expression representing the table you have access to now.

-> EntityField val2 (Key val1)

The foreign key field on the table.

-> (SqlExpr (Entity val1) -> SqlExpr (Value a))

A function to extract a value from the foreign reference table.

-> SqlExpr (Value a)

Performs a sub-select using the given foreign key on the entity. This is useful to extract values that are known to be present by the database schema.

As an example, consider the following persistent definition:

User
  profile ProfileId

Profile
  name    Text

The following query will return the name of the user.

getUserWithName =
    select $
    from $ user ->
    pure (user, subSelectForeign user UserProfile (^. ProfileName)

Since: 3.2.0

subSelectList :: PersistField a => SqlQuery (SqlExpr (Value a)) -> SqlExpr (ValueList a)

Execute a subquery SELECT in a SqlExpr that returns a list. This is an alias for subList_select and is provided for symmetry with the other safe subselect functions.

Since: 3.2.0

subSelectUnsafe :: PersistField a => SqlQuery (SqlExpr (Value a)) -> SqlExpr (Value a)

Execute a subquery SELECT in a SqlExpr. This function is unsafe, because it can throw runtime exceptions in two cases:

1. If the query passed has 0 result rows, then it will return a NULL value. The persistent parsing operations will fail on an unexpected NULL.
2. If the query passed returns more than one row, then the SQL engine will fail with an error like "More than one row returned by a subquery used as an expression".

This function is safe if you guarantee that exactly one row will be returned, or if the result already has a Maybe type for some reason.

For variants with the safety encoded already, see subSelect and subSelectMaybe. For the most common safe use of this, see subSelectCount.

Since: 3.2.0

class ToBaseId ent where

Class that enables one to use toBaseId to convert an entity's key on a query into another (cf. toBaseId).

Associated Types

type BaseEnt ent :: Type

e.g. type BaseEnt MyBase = MyChild

Methods

toBaseIdWitness :: Key (BaseEnt ent) -> Key ent

Convert from the key of the BaseEnt(ity) to the key of the child entity. This function is not actually called, but that it typechecks proves this operation is safe.

when_ :: expr (Value Bool) -> () -> expr a -> (expr (Value Bool), expr a)

Syntax sugar for case_.

Since: 2.1.2

then_ :: ()

Syntax sugar for case_.

Since: 2.1.2

else_ :: expr a -> expr a

Syntax sugar for case_.

Since: 2.1.2

from :: From a => (a -> SqlQuery b) -> SqlQuery b

FROM clause: bring entities into scope.

Note that this function will be replaced by the one in Database.Esqueleto.Experimental in version 4.0.0.0 of the library. The Experimental module has a dramatically improved means for introducing tables and entities that provides more power and less potential for runtime errors.

This function internally uses two type classes in order to provide some flexibility of how you may call it. Internally we refer to these type classes as the two different magics.

The innermost magic allows you to use from with the following types:

• expr (Entity val), which brings a single entity into scope.
• expr (Maybe (Entity val)), which brings a single entity that may be NULL into scope. Used for OUTER JOINs.
• A JOIN of any other two types allowed by the innermost magic, where a JOIN may be an InnerJoin, a CrossJoin, a LeftOuterJoin, a RightOuterJoin, or a FullOuterJoin. The JOINs have left fixity.

The outermost magic allows you to use from on any tuples of types supported by innermost magic (and also tuples of tuples, and so on), up to 8-tuples.

Note that using from for the same entity twice does work and corresponds to a self-join. You don't even need to use two different calls to from, you may use a JOIN or a tuple.

The following are valid examples of uses of from (the types of the arguments of the lambda are inside square brackets):

from $ \person -> ...
from $ \(person, blogPost) -> ...
from $ \(p `LeftOuterJoin` mb) -> ...
from $ \(p1 `InnerJoin` f `InnerJoin` p2) -> ...
from $ \((p1 `InnerJoin` f) `InnerJoin` p2) -> ...

The types of the arguments to the lambdas above are, respectively:

person
  :: ( Esqueleto query expr backend
     , PersistEntity Person
     , PersistEntityBackend Person ~ backend
     ) => expr (Entity Person)
(person, blogPost)
  :: (...) => (expr (Entity Person), expr (Entity BlogPost))
(p `LeftOuterJoin` mb)
  :: (...) => InnerJoin (expr (Entity Person)) (expr (Maybe (Entity BlogPost)))
(p1 `InnerJoin` f `InnerJoin` p2)
  :: (...) => InnerJoin
                (InnerJoin (expr (Entity Person))
                           (expr (Entity Follow)))
                (expr (Entity Person))
(p1 `InnerJoin` (f `InnerJoin` p2)) ::
  :: (...) => InnerJoin
                (expr (Entity Person))
                (InnerJoin (expr (Entity Follow))
                           (expr (Entity Person)))

Note that some backends may not support all kinds of JOINs.

newtype Value a

A single value (as opposed to a whole entity). You may use (^.) or (?.) to get a Value from an Entity.

Constructors

Value

Fields

• unValue :: a

Instances

Applicative Value

Defined in Database.Esqueleto.Internal.Internal

Methods

pure :: a -> Value a

(<*>) :: Value (a -> b) -> Value a -> Value b

liftA2 :: (a -> b -> c) -> Value a -> Value b -> Value c

(*>) :: Value a -> Value b -> Value b

(<*) :: Value a -> Value b -> Value a

Functor Value

Since: 1.4.4

Defined in Database.Esqueleto.Internal.Internal

Methods

fmap :: (a -> b) -> Value a -> Value b

(<$) :: a -> Value b -> Value a

Monad Value

Defined in Database.Esqueleto.Internal.Internal

Methods

(>>=) :: Value a -> (a -> Value b) -> Value b

(>>) :: Value a -> Value b -> Value b

return :: a -> Value a

(PersistEntity rec, PersistField typ, SymbolToField sym rec typ) => HasField (sym :: Symbol) (SqlExpr (Entity rec)) (SqlExpr (Value typ))

This instance allows you to use record.field notation with GHC 9.2's OverloadedRecordDot extension.

Example:

-- persistent model:
BlogPost
    authorId     PersonId
    title        Text

-- query:
select $ do
    bp <- from $ table @BlogPost
    pure $ bp.title

This is exactly equivalent to the following:

blogPost :: SqlExpr (Entity BlogPost)

blogPost ^. BlogPostTitle
blogPost ^. #title
blogPost.title

There's another instance defined on SqlExpr (Entity (Maybe rec)), which allows you to project from a LEFT JOINed entity.

Since: 3.5.4.0

Defined in Database.Esqueleto.Internal.Internal

Methods

getField :: SqlExpr (Entity rec) -> SqlExpr (Value typ)

(PersistEntity rec, PersistField typ, SymbolToField sym rec typ) => HasField (sym :: Symbol) (SqlExpr (Maybe (Entity rec))) (SqlExpr (Value (Maybe typ)))

This instance allows you to use record.field notation with GC 9.2's OverloadedRecordDot extension.

Example:

-- persistent model:
Person
    name         Text

BlogPost
    title        Text
    authorId     PersonId

-- query:

select $ do
    (p :& bp) <- from $
        table Person
        leftJoin table BlogPost
        on do
            \(p :& bp) ->
                just p.id ==. bp.authorId
    pure (p.name, bp.title)

The following forms are all equivalent:

blogPost :: SqlExpr (Maybe (Entity BlogPost))

blogPost ?. BlogPostTitle
blogPost ?. #title
blogPost.title

Since: 3.5.4.0

Defined in Database.Esqueleto.Internal.Internal

Methods

getField :: SqlExpr (Maybe (Entity rec)) -> SqlExpr (Value (Maybe typ))

(ToFrom a a', SqlSelect b r, ToAlias b, ToAliasReference b, d ~ (a' :& b)) => DoInnerJoin Lateral a (a' -> SqlQuery b, d -> SqlExpr (Value Bool)) d

Defined in Database.Esqueleto.Experimental.From.Join

Methods

doInnerJoin :: Proxy Lateral -> a -> (a' -> SqlQuery b, d -> SqlExpr (Value Bool)) -> From d

(ToFrom a a', ToMaybe b, d ~ (a' :& ToMaybeT b), SqlSelect b r, ToAlias b, ToAliasReference b) => DoLeftJoin Lateral a (a' -> SqlQuery b, d -> SqlExpr (Value Bool)) d

Defined in Database.Esqueleto.Experimental.From.Join

Methods

doLeftJoin :: Proxy Lateral -> a -> (a' -> SqlQuery b, d -> SqlExpr (Value Bool)) -> From d

Show a => Show (Value a)

Defined in Database.Esqueleto.Internal.Internal

Methods

showsPrec :: Int -> Value a -> ShowS

show :: Value a -> String

showList :: [Value a] -> ShowS

ToAlias (SqlExpr (Value a))

Defined in Database.Esqueleto.Experimental.ToAlias

Methods

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

ToAliasReference (SqlExpr (Value a))

Defined in Database.Esqueleto.Experimental.ToAliasReference

Methods

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

ToMaybe (SqlExpr (Value a))

Defined in Database.Esqueleto.Experimental.ToMaybe

Associated Types

type ToMaybeT (SqlExpr (Value a))

Methods

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

ToSomeValues (SqlExpr (Value a))

Defined in Database.Esqueleto.Internal.Internal

Methods

toSomeValues :: SqlExpr (Value a) -> [SomeValue]

Eq a => Eq (Value a)

Defined in Database.Esqueleto.Internal.Internal

Methods

(==) :: Value a -> Value a -> Bool

(/=) :: Value a -> Value a -> Bool

Ord a => Ord (Value a)

Defined in Database.Esqueleto.Internal.Internal

Methods

compare :: Value a -> Value a -> Ordering

(<) :: Value a -> Value a -> Bool

(<=) :: Value a -> Value a -> Bool

(>) :: Value a -> Value a -> Bool

(>=) :: Value a -> Value a -> Bool

max :: Value a -> Value a -> Value a

min :: Value a -> Value a -> Value a

PersistField a => SqlSelect (SqlExpr (Value a)) (Value a)

You may return any single value (i.e. a single column) from a select query.

Defined in Database.Esqueleto.Internal.Internal

Methods

sqlSelectCols :: IdentInfo -> SqlExpr (Value a) -> (Builder, [PersistValue])

sqlSelectColCount :: Proxy (SqlExpr (Value a)) -> Int

sqlSelectProcessRow :: [PersistValue] -> Either Text (Value a)

sqlInsertInto :: IdentInfo -> SqlExpr (Value a) -> (Builder, [PersistValue])

type ToMaybeT (SqlExpr (Value a))

Defined in Database.Esqueleto.Experimental.ToMaybe

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

newtype ValueList a

A list of single values. There's a limited set of functions able to work with this data type (such as subList_select, valList, in_ and exists).

Constructors

ValueList a

Instances

Show a => Show (ValueList a)

Defined in Database.Esqueleto.Internal.Internal

Methods

showsPrec :: Int -> ValueList a -> ShowS

show :: ValueList a -> String

showList :: [ValueList a] -> ShowS

Eq a => Eq (ValueList a)

Defined in Database.Esqueleto.Internal.Internal

Methods

(==) :: ValueList a -> ValueList a -> Bool

(/=) :: ValueList a -> ValueList a -> Bool

Ord a => Ord (ValueList a)

Defined in Database.Esqueleto.Internal.Internal

Methods

compare :: ValueList a -> ValueList a -> Ordering

(<) :: ValueList a -> ValueList a -> Bool

(<=) :: ValueList a -> ValueList a -> Bool

(>) :: ValueList a -> ValueList a -> Bool

(>=) :: ValueList a -> ValueList a -> Bool

max :: ValueList a -> ValueList a -> ValueList a

min :: ValueList a -> ValueList a -> ValueList a

data OrderBy

Phantom type used by orderBy, asc and desc.

data DistinctOn

Phantom type used by distinctOn and don.

data LockingKind

Different kinds of locking clauses supported by locking.

Note that each RDBMS has different locking support. The constructors of this datatype specify only the syntax of the locking mechanism, not its semantics. For example, even though both MySQL and PostgreSQL support ForUpdate, there are no guarantees that they will behave the same.

Since: 2.2.7

Constructors

ForUpdate

FOR UPDATE syntax. Supported by MySQL, Oracle and PostgreSQL.

Since: 2.2.7

ForUpdateSkipLocked

FOR UPDATE SKIP LOCKED syntax. Supported by MySQL, Oracle and PostgreSQL.

Since: 2.2.7

ForShare

FOR SHARE syntax. Supported by PostgreSQL.

Since: 2.2.7

LockInShareMode

LOCK IN SHARE MODE syntax. Supported by MySQL.

Since: 2.2.7

class LockableEntity a where

Lockable entity

Example use:

select $ do
    (p :& bp) <- from $
        table Person
        innerJoin table BlogPost
            on do
                (p :& bp) -> p ^. PersonId ==. b ^. BlogPostAuthorId
    forUpdateOf (p :& b) skipLocked
    return p

Methods

flattenLockableEntity :: a -> NonEmpty LockableSqlExpr

Instances

PersistEntity val => LockableEntity (SqlExpr (Entity val))

Defined in Database.Esqueleto.Internal.Internal

Methods

flattenLockableEntity :: SqlExpr (Entity val) -> NonEmpty LockableSqlExpr

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

Defined in Database.Esqueleto.Internal.Internal

Methods

flattenLockableEntity :: (a :& b) -> NonEmpty LockableSqlExpr

class PersistField a => SqlString a

Phantom class of data types that are treated as strings by the RDBMS. It has no methods because it's only used to avoid type errors such as trying to concatenate integers.

If you have a custom data type or newtype, feel free to make it an instance of this class.

Since: 2.4.0

Instances

SqlString Html

Since: 2.3.0

Defined in Database.Esqueleto.Internal.Internal

SqlString ByteString

Since: 2.3.0

Defined in Database.Esqueleto.Internal.Internal

SqlString Text

Since: 2.3.0

Defined in Database.Esqueleto.Internal.Internal

SqlString Text

Since: 2.3.0

Defined in Database.Esqueleto.Internal.Internal

SqlString a => SqlString (Maybe a)

Since: 2.4.0

Defined in Database.Esqueleto.Internal.Internal

a ~ Char => SqlString [a]

Since: 2.3.0

Defined in Database.Esqueleto.Internal.Internal

Joins

data InnerJoin a b infixl 2

Data type that represents an INNER JOIN (see LeftOuterJoin for an example).

Constructors

a `InnerJoin` b infixl 2

Instances

IsJoinKind InnerJoin

Defined in Database.Esqueleto.Internal.Internal

Methods

smartJoin :: a -> b -> InnerJoin a b

reifyJoinKind :: InnerJoin a b -> JoinKind

FromPreprocess (InnerJoin a b) => From (InnerJoin a b)

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (InnerJoin a b)

(DoInnerJoin lateral lhs rhs r, lateral ~ IsLateral rhs) => ToFrom (InnerJoin lhs rhs) r

Defined in Database.Esqueleto.Experimental.From.Join

Methods

toFrom :: InnerJoin lhs rhs -> From r

data CrossJoin a b infixl 2

Data type that represents a CROSS JOIN (see LeftOuterJoin for an example).

Constructors

a `CrossJoin` b infixl 2

Instances

IsJoinKind CrossJoin

Defined in Database.Esqueleto.Internal.Internal

Methods

smartJoin :: a -> b -> CrossJoin a b

reifyJoinKind :: CrossJoin a b -> JoinKind

FromPreprocess (CrossJoin a b) => From (CrossJoin a b)

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (CrossJoin a b)

(DoCrossJoin lateral lhs rhs r, IsLateral rhs ~ lateral) => ToFrom (CrossJoin lhs rhs) r

Defined in Database.Esqueleto.Experimental.From.Join

Methods

toFrom :: CrossJoin lhs rhs -> From r

data LeftOuterJoin a b infixl 2

Data type that represents a LEFT OUTER JOIN. For example,

select $
from $ \(person `LeftOuterJoin` pet) ->
  ...

is translated into

SELECT ...
FROM Person LEFT OUTER JOIN Pet
...

See also: from.

Constructors

a `LeftOuterJoin` b infixl 2

Instances

IsJoinKind LeftOuterJoin

Defined in Database.Esqueleto.Internal.Internal

Methods

smartJoin :: a -> b -> LeftOuterJoin a b

reifyJoinKind :: LeftOuterJoin a b -> JoinKind

FromPreprocess (LeftOuterJoin a b) => From (LeftOuterJoin a b)

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (LeftOuterJoin a b)

(DoLeftJoin lateral lhs rhs r, lateral ~ IsLateral rhs) => ToFrom (LeftOuterJoin lhs rhs) r

Defined in Database.Esqueleto.Experimental.From.Join

Methods

toFrom :: LeftOuterJoin lhs rhs -> From r

data RightOuterJoin a b infixl 2

Data type that represents a RIGHT OUTER JOIN (see LeftOuterJoin for an example).

Constructors

a `RightOuterJoin` b infixl 2

Instances

IsJoinKind RightOuterJoin

Defined in Database.Esqueleto.Internal.Internal

Methods

smartJoin :: a -> b -> RightOuterJoin a b

reifyJoinKind :: RightOuterJoin a b -> JoinKind

FromPreprocess (RightOuterJoin a b) => From (RightOuterJoin a b)

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (RightOuterJoin a b)

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

Defined in Database.Esqueleto.Experimental.From.Join

Methods

toFrom :: RightOuterJoin a rhs -> From (ma :& b')

data FullOuterJoin a b infixl 2

Data type that represents a FULL OUTER JOIN (see LeftOuterJoin for an example).

Constructors

a `FullOuterJoin` b infixl 2

Instances

IsJoinKind FullOuterJoin

Defined in Database.Esqueleto.Internal.Internal

Methods

smartJoin :: a -> b -> FullOuterJoin a b

reifyJoinKind :: FullOuterJoin a b -> JoinKind

FromPreprocess (FullOuterJoin a b) => From (FullOuterJoin a b)

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (FullOuterJoin a b)

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

Defined in Database.Esqueleto.Experimental.From.Join

Methods

toFrom :: FullOuterJoin a rhs -> From (ma :& mb)

data JoinKind

(Internal) A kind of JOIN.

Constructors

InnerJoinKind

INNER JOIN

CrossJoinKind

CROSS JOIN

LeftOuterJoinKind

LEFT OUTER JOIN

RightOuterJoinKind

RIGHT OUTER JOIN

FullOuterJoinKind

FULL OUTER JOIN

Instances

Show JoinKind

Defined in Database.Esqueleto.Internal.Internal

Methods

showsPrec :: Int -> JoinKind -> ShowS

show :: JoinKind -> String

showList :: [JoinKind] -> ShowS

Eq JoinKind

Defined in Database.Esqueleto.Internal.Internal

Methods

(==) :: JoinKind -> JoinKind -> Bool

(/=) :: JoinKind -> JoinKind -> Bool

data OnClauseWithoutMatchingJoinException

Exception thrown whenever on is used to create an ON clause but no matching JOIN is found.

Constructors

OnClauseWithoutMatchingJoinException String

Instances

Exception OnClauseWithoutMatchingJoinException

Defined in Database.Esqueleto.Internal.Internal

Methods

toException :: OnClauseWithoutMatchingJoinException -> SomeException

fromException :: SomeException -> Maybe OnClauseWithoutMatchingJoinException

displayException :: OnClauseWithoutMatchingJoinException -> String

Show OnClauseWithoutMatchingJoinException

Defined in Database.Esqueleto.Internal.Internal

Methods

showsPrec :: Int -> OnClauseWithoutMatchingJoinException -> ShowS

show :: OnClauseWithoutMatchingJoinException -> String

showList :: [OnClauseWithoutMatchingJoinException] -> ShowS

Eq OnClauseWithoutMatchingJoinException

Defined in Database.Esqueleto.Internal.Internal

Methods

(==) :: OnClauseWithoutMatchingJoinException -> OnClauseWithoutMatchingJoinException -> Bool

(/=) :: OnClauseWithoutMatchingJoinException -> OnClauseWithoutMatchingJoinException -> Bool

Ord OnClauseWithoutMatchingJoinException

Defined in Database.Esqueleto.Internal.Internal

Methods

compare :: OnClauseWithoutMatchingJoinException -> OnClauseWithoutMatchingJoinException -> Ordering

(<) :: OnClauseWithoutMatchingJoinException -> OnClauseWithoutMatchingJoinException -> Bool

(<=) :: OnClauseWithoutMatchingJoinException -> OnClauseWithoutMatchingJoinException -> Bool

(>) :: OnClauseWithoutMatchingJoinException -> OnClauseWithoutMatchingJoinException -> Bool

(>=) :: OnClauseWithoutMatchingJoinException -> OnClauseWithoutMatchingJoinException -> Bool

max :: OnClauseWithoutMatchingJoinException -> OnClauseWithoutMatchingJoinException -> OnClauseWithoutMatchingJoinException

min :: OnClauseWithoutMatchingJoinException -> OnClauseWithoutMatchingJoinException -> OnClauseWithoutMatchingJoinException

SQL backend

data SqlQuery a

SQL backend for esqueleto using SqlPersistT.

Instances

Applicative SqlQuery

Defined in Database.Esqueleto.Internal.Internal

Methods

pure :: a -> SqlQuery a

(<*>) :: SqlQuery (a -> b) -> SqlQuery a -> SqlQuery b

liftA2 :: (a -> b -> c) -> SqlQuery a -> SqlQuery b -> SqlQuery c

(*>) :: SqlQuery a -> SqlQuery b -> SqlQuery b

(<*) :: SqlQuery a -> SqlQuery b -> SqlQuery a

Functor SqlQuery

Defined in Database.Esqueleto.Internal.Internal

Methods

fmap :: (a -> b) -> SqlQuery a -> SqlQuery b

(<$) :: a -> SqlQuery b -> SqlQuery a

Monad SqlQuery

Defined in Database.Esqueleto.Internal.Internal

Methods

(>>=) :: SqlQuery a -> (a -> SqlQuery b) -> SqlQuery b

(>>) :: SqlQuery a -> SqlQuery b -> SqlQuery b

return :: a -> SqlQuery a

(ToFrom a a', SqlSelect b r, ToAlias b, ToAliasReference b, d ~ (a' :& b)) => DoInnerJoin Lateral a (a' -> SqlQuery b, d -> SqlExpr (Value Bool)) d

Defined in Database.Esqueleto.Experimental.From.Join

Methods

doInnerJoin :: Proxy Lateral -> a -> (a' -> SqlQuery b, d -> SqlExpr (Value Bool)) -> From d

(ToFrom a a', ToMaybe b, d ~ (a' :& ToMaybeT b), SqlSelect b r, ToAlias b, ToAliasReference b) => DoLeftJoin Lateral a (a' -> SqlQuery b, d -> SqlExpr (Value Bool)) d

Defined in Database.Esqueleto.Experimental.From.Join

Methods

doLeftJoin :: Proxy Lateral -> a -> (a' -> SqlQuery b, d -> SqlExpr (Value Bool)) -> From d

(ToFrom a a', SqlSelect b r, ToAlias b, ToAliasReference b) => DoCrossJoin Lateral a (a' -> SqlQuery b) (a' :& b)

Defined in Database.Esqueleto.Experimental.From.Join

Methods

doCrossJoin :: Proxy Lateral -> a -> (a' -> SqlQuery b) -> From (a' :& b)

(SqlSelect a r, ToAlias a, ToAliasReference a) => ToFrom (SubQuery (SqlQuery a)) a

Defined in Database.Esqueleto.Experimental.From

Methods

toFrom :: SubQuery (SqlQuery a) -> From a

(SqlSelect a r, ToAlias a, ToAliasReference a) => ToFrom (SqlQuery a) a

Defined in Database.Esqueleto.Experimental.From

Methods

toFrom :: SqlQuery a -> From a

(SqlSelect a r, ToAlias a, ToAliasReference a) => ToSqlSetOperation (SqlQuery a) a

Defined in Database.Esqueleto.Experimental.From.SqlSetOperation

Methods

toSqlSetOperation :: SqlQuery a -> SqlSetOperation a

ValidOnClause (a -> SqlQuery b)

Defined in Database.Esqueleto.Experimental.From.Join

data SqlExpr a

An expression on the SQL backend.

Raw expression: Contains a SqlExprMeta and a function for building the expr. It recieves a parameter telling it whether it is in a parenthesized context, and takes information about the SQL connection (mainly for escaping names) and returns both an string (Builder) and a list of values to be interpolated by the SQL backend.

Instances

(TypeError SqlExprFunctorMessage :: Constraint) => Functor SqlExpr

Folks often want the ability to promote a Haskell function into the SqlExpr expression language - and naturally reach for fmap. Unfortunately, this is impossible. We cannot send *functions* to the database, which is what we would need to do in order for this to make sense. Let's consider the type of fmap for SqlExpr:

fmap :: (a -> b) -> SqlExpr a -> SqlExpr b

This type signature is making a pretty strong claim: "Give me a Haskell function from a -> b. I will then transform a SQL expression representing a Haskell value of type a and turn it into a SQL expression representing a Haskell value of type b."

Let's suppose we *could* do this - fmap (+1) would have to somehow inspect the function expression means "add one", and then translate that to the appropriate SQL.

This is why esqueleto defines a bunch of operators: x +. (val 1) can be used instead of fmap (+1) x.

If you do have a SQL function, then you can provide a safe type and introduce it with unsafeSqlFunction or unsafeSqlBinOp.

Since: 3.5.8.2

Defined in Database.Esqueleto.Internal.Internal

Methods

fmap :: (a -> b) -> SqlExpr a -> SqlExpr b

(<$) :: a -> SqlExpr b -> SqlExpr a

(PersistEntity rec, PersistField typ, SymbolToField sym rec typ) => HasField (sym :: Symbol) (SqlExpr (Entity rec)) (SqlExpr (Value typ))

This instance allows you to use record.field notation with GHC 9.2's OverloadedRecordDot extension.

Example:

-- persistent model:
BlogPost
    authorId     PersonId
    title        Text

-- query:
select $ do
    bp <- from $ table @BlogPost
    pure $ bp.title

This is exactly equivalent to the following:

blogPost :: SqlExpr (Entity BlogPost)

blogPost ^. BlogPostTitle
blogPost ^. #title
blogPost.title

There's another instance defined on SqlExpr (Entity (Maybe rec)), which allows you to project from a LEFT JOINed entity.

Since: 3.5.4.0

Defined in Database.Esqueleto.Internal.Internal

Methods

getField :: SqlExpr (Entity rec) -> SqlExpr (Value typ)

(PersistEntity rec, PersistField typ, SymbolToField sym rec typ) => HasField (sym :: Symbol) (SqlExpr (Maybe (Entity rec))) (SqlExpr (Value (Maybe typ)))

This instance allows you to use record.field notation with GC 9.2's OverloadedRecordDot extension.

Example:

-- persistent model:
Person
    name         Text

BlogPost
    title        Text
    authorId     PersonId

-- query:

select $ do
    (p :& bp) <- from $
        table Person
        leftJoin table BlogPost
        on do
            \(p :& bp) ->
                just p.id ==. bp.authorId
    pure (p.name, bp.title)

The following forms are all equivalent:

blogPost :: SqlExpr (Maybe (Entity BlogPost))

blogPost ?. BlogPostTitle
blogPost ?. #title
blogPost.title

Since: 3.5.4.0

Defined in Database.Esqueleto.Internal.Internal

Methods

getField :: SqlExpr (Maybe (Entity rec)) -> SqlExpr (Value (Maybe typ))

(ToFrom a a', SqlSelect b r, ToAlias b, ToAliasReference b, d ~ (a' :& b)) => DoInnerJoin Lateral a (a' -> SqlQuery b, d -> SqlExpr (Value Bool)) d

Defined in Database.Esqueleto.Experimental.From.Join

Methods

doInnerJoin :: Proxy Lateral -> a -> (a' -> SqlQuery b, d -> SqlExpr (Value Bool)) -> From d

(ToFrom a a', ToMaybe b, d ~ (a' :& ToMaybeT b), SqlSelect b r, ToAlias b, ToAliasReference b) => DoLeftJoin Lateral a (a' -> SqlQuery b, d -> SqlExpr (Value Bool)) d

Defined in Database.Esqueleto.Experimental.From.Join

Methods

doLeftJoin :: Proxy Lateral -> a -> (a' -> SqlQuery b, d -> SqlExpr (Value Bool)) -> From d

ToAlias (SqlExpr (Value a))

Defined in Database.Esqueleto.Experimental.ToAlias

Methods

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

ToAlias (SqlExpr (Entity a))

Defined in Database.Esqueleto.Experimental.ToAlias

Methods

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

ToAlias (SqlExpr (Maybe (Entity a)))

Defined in Database.Esqueleto.Experimental.ToAlias

Methods

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

ToAliasReference (SqlExpr (Value a))

Defined in Database.Esqueleto.Experimental.ToAliasReference

Methods

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

ToAliasReference (SqlExpr (Entity a))

Defined in Database.Esqueleto.Experimental.ToAliasReference

Methods

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

ToAliasReference (SqlExpr (Maybe (Entity a)))

Defined in Database.Esqueleto.Experimental.ToAliasReference

Methods

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

ToMaybe (SqlExpr (Value a))

Defined in Database.Esqueleto.Experimental.ToMaybe

Associated Types

type ToMaybeT (SqlExpr (Value a))

Methods

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

ToMaybe (SqlExpr (Entity a))

Defined in Database.Esqueleto.Experimental.ToMaybe

Associated Types

type ToMaybeT (SqlExpr (Entity a))

Methods

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

ToMaybe (SqlExpr (Maybe a))

Defined in Database.Esqueleto.Experimental.ToMaybe

Associated Types

type ToMaybeT (SqlExpr (Maybe a))

Methods

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

FromPreprocess (SqlExpr (Entity val)) => From (SqlExpr (Entity val))

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (SqlExpr (Entity val))

FromPreprocess (SqlExpr (Maybe (Entity val))) => From (SqlExpr (Maybe (Entity val)))

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (SqlExpr (Maybe (Entity val)))

(PersistEntity val, BackendCompatible SqlBackend (PersistEntityBackend val)) => FromPreprocess (SqlExpr (Entity val))

Defined in Database.Esqueleto.Internal.Internal

Methods

fromPreprocess :: SqlQuery (PreprocessedFrom (SqlExpr (Entity val)))

(PersistEntity val, BackendCompatible SqlBackend (PersistEntityBackend val)) => FromPreprocess (SqlExpr (Maybe (Entity val)))

Defined in Database.Esqueleto.Internal.Internal

Methods

fromPreprocess :: SqlQuery (PreprocessedFrom (SqlExpr (Maybe (Entity val))))

PersistEntity val => LockableEntity (SqlExpr (Entity val))

Defined in Database.Esqueleto.Internal.Internal

Methods

flattenLockableEntity :: SqlExpr (Entity val) -> NonEmpty LockableSqlExpr

ToSomeValues (SqlExpr (Value a))

Defined in Database.Esqueleto.Internal.Internal

Methods

toSomeValues :: SqlExpr (Value a) -> [SomeValue]

a ~ Value b => UnsafeSqlFunctionArgument (SqlExpr a)

Defined in Database.Esqueleto.Internal.Internal

Methods

toArgList :: SqlExpr a -> [SqlExpr (Value ())]

PersistEntity ent => ToFrom (Table ent) (SqlExpr (Entity ent))

Defined in Database.Esqueleto.Experimental.From

Methods

toFrom :: Table ent -> From (SqlExpr (Entity ent))

PersistEntity e => SqlSelect (SqlExpr (Insertion e)) (Insertion e)

INSERT INTO hack.

Defined in Database.Esqueleto.Internal.Internal

Methods

sqlSelectCols :: IdentInfo -> SqlExpr (Insertion e) -> (Builder, [PersistValue])

sqlSelectColCount :: Proxy (SqlExpr (Insertion e)) -> Int

sqlSelectProcessRow :: [PersistValue] -> Either Text (Insertion e)

sqlInsertInto :: IdentInfo -> SqlExpr (Insertion e) -> (Builder, [PersistValue])

PersistField a => SqlSelect (SqlExpr (Value a)) (Value a)

You may return any single value (i.e. a single column) from a select query.

Defined in Database.Esqueleto.Internal.Internal

Methods

sqlSelectCols :: IdentInfo -> SqlExpr (Value a) -> (Builder, [PersistValue])

sqlSelectColCount :: Proxy (SqlExpr (Value a)) -> Int

sqlSelectProcessRow :: [PersistValue] -> Either Text (Value a)

sqlInsertInto :: IdentInfo -> SqlExpr (Value a) -> (Builder, [PersistValue])

PersistEntity a => SqlSelect (SqlExpr (Entity a)) (Entity a)

You may return an Entity from a select query.

Defined in Database.Esqueleto.Internal.Internal

Methods

sqlSelectCols :: IdentInfo -> SqlExpr (Entity a) -> (Builder, [PersistValue])

sqlSelectColCount :: Proxy (SqlExpr (Entity a)) -> Int

sqlSelectProcessRow :: [PersistValue] -> Either Text (Entity a)

sqlInsertInto :: IdentInfo -> SqlExpr (Entity a) -> (Builder, [PersistValue])

PersistEntity a => SqlSelect (SqlExpr (Maybe (Entity a))) (Maybe (Entity a))

You may return a possibly-NULL Entity from a select query.

Defined in Database.Esqueleto.Internal.Internal

Methods

sqlSelectCols :: IdentInfo -> SqlExpr (Maybe (Entity a)) -> (Builder, [PersistValue])

sqlSelectColCount :: Proxy (SqlExpr (Maybe (Entity a))) -> Int

sqlSelectProcessRow :: [PersistValue] -> Either Text (Maybe (Entity a))

sqlInsertInto :: IdentInfo -> SqlExpr (Maybe (Entity a)) -> (Builder, [PersistValue])

type ToMaybeT (SqlExpr (Value a))

Defined in Database.Esqueleto.Experimental.ToMaybe

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

type ToMaybeT (SqlExpr (Entity a))

Defined in Database.Esqueleto.Experimental.ToMaybe

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

type ToMaybeT (SqlExpr (Maybe a))

Defined in Database.Esqueleto.Experimental.ToMaybe

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

type SqlEntity ent = (PersistEntity ent, PersistEntityBackend ent ~ SqlBackend)

Constraint synonym for persistent entities whose backend is SqlBackend.

select :: (SqlSelect a r, MonadIO m, SqlBackendCanRead backend) => SqlQuery a -> ReaderT backend m [r]

Execute an esqueleto SELECT query inside persistent's SqlPersistT monad and return a list of rows.

We've seen that from has some magic about which kinds of things you may bring into scope. This select function also has some magic for which kinds of things you may bring back to Haskell-land by using SqlQuery's return:

• You may return a SqlExpr (Entity v) for an entity v (i.e., like the * in SQL), which is then returned to Haskell-land as just Entity v.
• You may return a SqlExpr (Maybe (Entity v)) for an entity v that may be NULL, which is then returned to Haskell-land as Maybe (Entity v). Used for OUTER JOINs.
• You may return a SqlExpr (Value t) for a value t (i.e., a single column), where t is any instance of PersistField, which is then returned to Haskell-land as Value t. You may use Value to return projections of an Entity (see (^.) and (?.)) or to return any other value calculated on the query (e.g., countRows or subSelect).

The SqlSelect a r class has functional dependencies that allow type information to flow both from a to r and vice-versa. This means that you'll almost never have to give any type signatures for esqueleto queries. For example, the query select $ from $ \p -> return p alone is ambiguous, but in the context of

do ps <- select $
         from $ \p ->
         return p
   liftIO $ mapM_ (putStrLn . personName . entityVal) ps

we are able to infer from that single personName . entityVal function composition that the p inside the query is of type SqlExpr (Entity Person).

selectOne :: (SqlSelect a r, MonadIO m, SqlBackendCanRead backend) => SqlQuery a -> ReaderT backend m (Maybe r)

Execute an esqueleto SELECT query inside persistent's SqlPersistT monad and return the first entry wrapped in a Maybe. @since 3.5.1.0

Example usage

firstPerson :: MonadIO m => SqlPersistT m (Maybe (Entity Person))
firstPerson =
 selectOne $ do
     person <- from $ table @Person
     return person

The above query is equivalent to a select combined with limit but you would still have to transform the results from a list:

firstPerson :: MonadIO m => SqlPersistT m [Entity Person]
firstPerson =
 select $ do
     person <- from $ table @Person
     limit 1
     return person

selectSource :: (SqlSelect a r, BackendCompatible SqlBackend backend, IsPersistBackend backend, PersistQueryRead backend, PersistStoreRead backend, PersistUniqueRead backend, MonadResource m) => SqlQuery a -> ConduitT () r (ReaderT backend m) ()

Execute an esqueleto SELECT query inside persistent's SqlPersistT monad and return a Source of rows.

delete :: (MonadIO m, SqlBackendCanWrite backend) => SqlQuery () -> ReaderT backend m ()

Execute an esqueleto DELETE query inside persistent's SqlPersistT monad. Note that currently there are no type checks for statements that should not appear on a DELETE query.

Example of usage:

delete $
from $ \appointment ->
where_ (appointment ^. AppointmentDate <. val now)

Unlike select, there is a useful way of using delete that will lead to type ambiguities. If you want to delete all rows (i.e., no where_ clause), you'll have to use a type signature:

delete $
from $ \(appointment :: SqlExpr (Entity Appointment)) ->
return ()

Database.Esqueleto.Experimental:

 delete $ do
   userFeature <- from $ table @UserFeature
   where_ ((userFeature ^. UserFeatureFeature) notIn valList allKnownFeatureFlags)

deleteCount :: (MonadIO m, SqlBackendCanWrite backend) => SqlQuery () -> ReaderT backend m Int64

Same as delete, but returns the number of rows affected.

update :: (MonadIO m, PersistEntity val, BackendCompatible SqlBackend (PersistEntityBackend val), SqlBackendCanWrite backend) => (SqlExpr (Entity val) -> SqlQuery ()) -> ReaderT backend m ()

Execute an esqueleto UPDATE query inside persistent's SqlPersistT monad. Note that currently there are no type checks for statements that should not appear on a UPDATE query.

Example of usage:

update $ \p -> do
set p [ PersonAge =. just (val thisYear) -. p ^. PersonBorn ]
where_ $ isNothing (p ^. PersonAge)

updateCount :: (MonadIO m, PersistEntity val, BackendCompatible SqlBackend (PersistEntityBackend val), SqlBackendCanWrite backend) => (SqlExpr (Entity val) -> SqlQuery ()) -> ReaderT backend m Int64

Same as update, but returns the number of rows affected.

insertSelect :: (MonadIO m, PersistEntity a, SqlBackendCanWrite backend) => SqlQuery (SqlExpr (Insertion a)) -> ReaderT backend m ()

Insert a PersistField for every selected value.

Since: 2.4.2

insertSelectCount :: (MonadIO m, PersistEntity a, SqlBackendCanWrite backend) => SqlQuery (SqlExpr (Insertion a)) -> ReaderT backend m Int64

Insert a PersistField for every selected value, return the count afterward

(<#) :: (a -> b) -> SqlExpr (Value a) -> SqlExpr (Insertion b)

Apply a PersistField constructor to SqlExpr Value arguments.

(<&>) :: SqlExpr (Insertion (a -> b)) -> SqlExpr (Value a) -> SqlExpr (Insertion b)

Apply extra SqlExpr Value arguments to a PersistField constructor

Rendering Queries

renderQueryToText

Arguments

:: (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m)

=> Mode

Whether to render as an SELECT, DELETE, etc.

-> SqlQuery a

The SQL query you want to render.

-> ReaderT backend m (Text, [PersistValue])

Renders a SqlQuery into a Text value along with the list of PersistValues that would be supplied to the database for ? placeholders.

You must ensure that the Mode you pass to this function corresponds with the actual SqlQuery. If you pass a query that uses incompatible features (like an INSERT statement with a SELECT mode) then you'll get a weird result.

Since: 3.1.1

renderQuerySelect

Arguments

:: (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m)

=> SqlQuery a

The SQL query you want to render.

-> ReaderT backend m (Text, [PersistValue])

Renders a SqlQuery into a Text value along with the list of PersistValues that would be supplied to the database for ? placeholders.

Since: 3.1.1

renderQueryUpdate

Arguments

:: (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m)

=> SqlQuery a

The SQL query you want to render.

-> ReaderT backend m (Text, [PersistValue])

Renders a SqlQuery into a Text value along with the list of PersistValues that would be supplied to the database for ? placeholders.

Since: 3.1.1

renderQueryDelete

Arguments

:: (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m)

=> SqlQuery a

The SQL query you want to render.

-> ReaderT backend m (Text, [PersistValue])

Renders a SqlQuery into a Text value along with the list of PersistValues that would be supplied to the database for ? placeholders.

Since: 3.1.1

renderQueryInsertInto

Arguments

:: (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m)

=> SqlQuery a

The SQL query you want to render.

-> ReaderT backend m (Text, [PersistValue])

Renders a SqlQuery into a Text value along with the list of PersistValues that would be supplied to the database for ? placeholders.

Since: 3.1.1

Internal.Language

class From a

(Internal) Class that implements the tuple from magic (see fromStart).

Minimal complete definition

from_

Instances

FromPreprocess (SqlExpr (Entity val)) => From (SqlExpr (Entity val))

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (SqlExpr (Entity val))

FromPreprocess (SqlExpr (Maybe (Entity val))) => From (SqlExpr (Maybe (Entity val)))

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (SqlExpr (Maybe (Entity val)))

FromPreprocess (CrossJoin a b) => From (CrossJoin a b)

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (CrossJoin a b)

FromPreprocess (FullOuterJoin a b) => From (FullOuterJoin a b)

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (FullOuterJoin a b)

FromPreprocess (InnerJoin a b) => From (InnerJoin a b)

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (InnerJoin a b)

FromPreprocess (LeftOuterJoin a b) => From (LeftOuterJoin a b)

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (LeftOuterJoin a b)

FromPreprocess (RightOuterJoin a b) => From (RightOuterJoin a b)

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (RightOuterJoin a b)

(From a, From b) => From (a, b)

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (a, b)

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

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (a, b, c)

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

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (a, b, c, d)

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

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (a, b, c, d, e)

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

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (a, b, c, d, e, f)

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

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (a, b, c, d, e, f, g)

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

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (a, b, c, d, e, f, g, h)

RDBMS-specific modules

There are many differences between SQL syntax and functions supported by different RDBMSs. Since version 2.2.8, esqueleto includes modules containing functions that are specific to a given RDBMS.

• PostgreSQL: Database.Esqueleto.PostgreSQL.

In order to use these functions, you need to explicitly import their corresponding modules, they're not re-exported here.

Helpers

valkey :: (ToBackendKey SqlBackend entity, PersistField (Key entity)) => Int64 -> SqlExpr (Value (Key entity))

valkey i = val . toSqlKey (https://github.com/prowdsponsor/esqueleto/issues/9).

valJ :: PersistField (Key entity) => Value (Key entity) -> SqlExpr (Value (Key entity))

valJ is like val but for something that is already a Value. The use case it was written for was, given a Value lift the Key for that Value into the query expression in a type safe way. However, the implementation is more generic than that so we call it valJ.

Its important to note that the input entity and the output entity are constrained to be the same by the type signature on the function (https://github.com/prowdsponsor/esqueleto/pull/69).

Since: 1.4.2

associateJoin :: forall e1 e0. Ord (Key e0) => [(Entity e0, e1)] -> Map (Key e0) (e0, [e1])

Avoid N+1 queries and join entities into a map structure.

This function is useful to call on the result of a single JOIN. For example, suppose you have this query:

getFoosAndNestedBarsFromParent
    :: ParentId
    -> SqlPersistT IO [(Entity Foo, Maybe (Entity Bar))]
getFoosAndNestedBarsFromParent parentId =
    select $ do
        (foo :& bar) <- from $
            table Foo
            `LeftOuterJoin`
            table Bar
                `on` do
                    \(foo :& bar) ->
                        foo ^. FooId ==. bar ?. BarFooId
        where_ $
            foo ^. FooParentId ==. val parentId
        pure (foo, bar)

This is a natural result type for SQL - a list of tuples. However, it's not what we usually want in Haskell - each Foo in the list will be represented multiple times, once for each Bar.

We can write fmap associateJoin and it will translate it into a Map that is keyed on the Key of the left Entity, and the value is a tuple of the entity's value as well as the list of each coresponding entity.

getFoosAndNestedBarsFromParentHaskellese
    :: ParentId
    -> SqlPersistT (Map (Key Foo) (Foo, [Maybe (Entity Bar)]))
getFoosAndNestedBarsFromParentHaskellese parentId =
    fmap associateJoin $ getFoosdAndNestedBarsFromParent parentId

What if you have multiple joins?

Let's use associateJoin with a *two* join query.

userPostComments
    :: SqlQuery (SqlExpr (Entity User, Entity Post, Entity Comment))
userPostsComment = do
    (u :& p :& c) <- from $
        table User
        `InnerJoin`
        table Post
            on do
                \(u :& p) ->
                    u ^. UserId ==. p ^. PostUserId
        `InnerJoin`
        table @Comment
            `on` do
                \(_ :& p :& c) ->
                    p ^. PostId ==. c ^. CommentPostId
    pure (u, p, c)

This query returns a User, with all of the users Posts, and then all of the Comments on that post.

First, we *nest* the tuple.

nest :: (a, b, c) -> (a, (b, c))
nest (a, b, c) = (a, (b, c))

This makes the return of the query conform to the input expected from associateJoin.

nestedUserPostComments
    :: SqlPersistT IO [(Entity User, (Entity Post, Entity Comment))]
nestedUserPostComments =
    fmap nest $ select userPostsComments

Now, we can call associateJoin on it.

associateUsers
    :: [(Entity User, (Entity Post, Entity Comment))]
    -> Map UserId (User, [(Entity Post, Entity Comment)])
associateUsers =
    associateJoin

Next, we'll use the Functor instances for Map and tuple to call associateJoin on the [(Entity Post, Entity Comment)].

associatePostsAndComments
    :: Map UserId (User, [(Entity Post, Entity Comment)])
    -> Map UserId (User, Map PostId (Post, [Entity Comment]))
associatePostsAndComments =
    fmap (fmap associateJoin)

For more reading on this topic, see this Foxhound Systems blog post.

Since: 3.1.2

Re-exports

We re-export many symbols from persistent for convenince:

• "Store functions" from Database.Persist.
• Everything from Database.Persist.Class except for PersistQuery and delete (use deleteKey instead).
• Everything from Database.Persist.Types except for Update, SelectOpt, BackendSpecificFilter and Filter.
• Everything from Database.Persist.Sql except for deleteWhereCount and updateWhereCount.

deleteKey :: (PersistStore backend, BaseBackend backend ~ PersistEntityBackend val, MonadIO m, PersistEntity val) => Key val -> ReaderT backend m ()

Synonym for delete that does not clash with esqueleto's delete.

class (PersistField (Key record), ToJSON (Key record), FromJSON (Key record), Show (Key record), Read (Key record), Eq (Key record), Ord (Key record)) => PersistEntity record where

Persistent serialized Haskell records to the database. A Database Entity (A row in SQL, a document in MongoDB, etc) corresponds to a Key plus a Haskell record.

For every Haskell record type stored in the database there is a corresponding PersistEntity instance. An instance of PersistEntity contains meta-data for the record. PersistEntity also helps abstract over different record types. That way the same query interface can return a PersistEntity, with each query returning different types of Haskell records.

Some advanced type system capabilities are used to make this process type-safe. Persistent users usually don't need to understand the class associated data and functions.

Minimal complete definition

keyToValues, keyFromValues, persistIdField, entityDef, persistFieldDef, toPersistFields, fromPersistValues, tabulateEntityA, persistUniqueKeys, persistUniqueToFieldNames, persistUniqueToValues, fieldLens

Associated Types

type PersistEntityBackend record

Persistent allows multiple different backends (databases).

data Key record

By default, a backend will automatically generate the key Instead you can specify a Primary key made up of unique values.

data EntityField record :: Type -> Type

An EntityField is parameterised by the Haskell record it belongs to and the additional type of that field.

As of persistent-2.11.0.0, it's possible to use the OverloadedLabels language extension to refer to EntityField values polymorphically. See the documentation on SymbolToField for more information.

data Unique record

Unique keys besides the Key.

Methods

keyToValues :: Key record -> [PersistValue]

A lower-level key operation.

keyFromValues :: [PersistValue] -> Either Text (Key record)

A lower-level key operation.

persistIdField :: EntityField record (Key record)

A meta-operation to retrieve the Key EntityField.

entityDef :: proxy record -> EntityDef

Retrieve the EntityDef meta-data for the record.

persistFieldDef :: EntityField record typ -> FieldDef

Return meta-data for a given EntityField.

toPersistFields :: record -> [PersistValue]

A meta-operation to get the database fields of a record.

fromPersistValues :: [PersistValue] -> Either Text record

A lower-level operation to convert from database values to a Haskell record.

tabulateEntityA

Arguments

:: Applicative f

=> (forall a. EntityField record a -> f a)

A function that builds a fragment of a record in an Applicative context.

-> f (Entity record)

This function allows you to build an Entity a by specifying an action that returns a value for the field in the callback function. Let's look at an example.

parseFromEnvironmentVariables :: IO (Entity User)
parseFromEnvironmentVariables =
    tabulateEntityA $ \userField ->
        case userField of
            UserName ->
                getEnv USER_NAME
            UserAge -> do
                ageVar <- getEnv USER_AGE
                case readMaybe ageVar of
                    Just age ->
                        pure age
                    Nothing ->
                        error $ "Failed to parse Age from: " <> ageVar
            UserAddressId -> do
                addressVar <- getEnv USER_ADDRESS_ID
                pure $ AddressKey addressVar

Since: persistent-2.14.0.0

persistUniqueKeys :: record -> [Unique record]

A meta operation to retrieve all the Unique keys.

persistUniqueToFieldNames :: Unique record -> NonEmpty (FieldNameHS, FieldNameDB)

A lower level operation.

persistUniqueToValues :: Unique record -> [PersistValue]

A lower level operation.

fieldLens :: EntityField record field -> forall (f :: Type -> Type). Functor f => (field -> f field) -> Entity record -> f (Entity record)

Use a PersistField as a lens.

keyFromRecordM :: Maybe (record -> Key record)

Extract a Key record from a record value. Currently, this is only defined for entities using the Primary syntax for natural/composite keys. In a future version of persistent which incorporates the ID directly into the entity, this will always be Just.

Since: persistent-2.11.0.0

data family Key record

By default, a backend will automatically generate the key Instead you can specify a Primary key made up of unique values.

Instances

(PersistEntity a, PersistEntityBackend a ~ backend, IsPersistBackend backend) => RawSql (Key a)

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> Key a -> (Int, [Text])

rawSqlColCountReason :: Key a -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (Key a)

data family Unique record

Unique keys besides the Key.

Instances

FinalResult (Unique val)

Defined in Database.Esqueleto.Internal.Internal

Methods

finalR :: Unique val -> KnowResult (Unique val)

newtype Single a

A single column (see rawSql). Any PersistField may be used here, including PersistValue (which does not do any processing).

Constructors

Single

Fields

• unSingle :: a

Instances

Read a => Read (Single a)

Defined in Database.Persist.Sql.Types

Methods

readsPrec :: Int -> ReadS (Single a)

readList :: ReadS [Single a]

readPrec :: ReadPrec (Single a)

readListPrec :: ReadPrec [Single a]

Show a => Show (Single a)

Defined in Database.Persist.Sql.Types

Methods

showsPrec :: Int -> Single a -> ShowS

show :: Single a -> String

showList :: [Single a] -> ShowS

Eq a => Eq (Single a)

Defined in Database.Persist.Sql.Types

Methods

(==) :: Single a -> Single a -> Bool

(/=) :: Single a -> Single a -> Bool

Ord a => Ord (Single a)

Defined in Database.Persist.Sql.Types

Methods

compare :: Single a -> Single a -> Ordering

(<) :: Single a -> Single a -> Bool

(<=) :: Single a -> Single a -> Bool

(>) :: Single a -> Single a -> Bool

(>=) :: Single a -> Single a -> Bool

max :: Single a -> Single a -> Single a

min :: Single a -> Single a -> Single a

PersistField a => RawSql (Single a)

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> Single a -> (Int, [Text])

rawSqlColCountReason :: Single a -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (Single a)

data Column

Constructors

Column

Fields

• cName :: !FieldNameDB
• cNull :: !Bool
• cSqlType :: !SqlType
• cDefault :: !(Maybe Text)
• cGenerated :: !(Maybe Text)
• cDefaultConstraintName :: !(Maybe ConstraintNameDB)
• cMaxLen :: !(Maybe Integer)
• cReference :: !(Maybe ColumnReference)

Instances

Show Column

Defined in Database.Persist.Sql.Types

Methods

showsPrec :: Int -> Column -> ShowS

show :: Column -> String

showList :: [Column] -> ShowS

Eq Column

Defined in Database.Persist.Sql.Types

Methods

(==) :: Column -> Column -> Bool

(/=) :: Column -> Column -> Bool

Ord Column

Defined in Database.Persist.Sql.Types

Methods

compare :: Column -> Column -> Ordering

(<) :: Column -> Column -> Bool

(<=) :: Column -> Column -> Bool

(>) :: Column -> Column -> Bool

(>=) :: Column -> Column -> Bool

max :: Column -> Column -> Column

min :: Column -> Column -> Column

class PersistConfig c where

Represents a value containing all the configuration options for a specific backend. This abstraction makes it easier to write code that can easily swap backends.

Minimal complete definition

loadConfig, createPoolConfig, runPool

Associated Types

type PersistConfigBackend c :: (Type -> Type) -> Type -> Type

type PersistConfigPool c

Methods

loadConfig :: Value -> Parser c

Load the config settings from a Value, most likely taken from a YAML config file.

applyEnv :: c -> IO c

Modify the config settings based on environment variables.

createPoolConfig :: c -> IO (PersistConfigPool c)

Create a new connection pool based on the given config settings.

runPool :: MonadUnliftIO m => c -> PersistConfigBackend c m a -> PersistConfigPool c -> m a

Run a database action by taking a connection from the pool.

Instances

(PersistConfig c1, PersistConfig c2, PersistConfigPool c1 ~ PersistConfigPool c2, PersistConfigBackend c1 ~ PersistConfigBackend c2) => PersistConfig (Either c1 c2)

Defined in Database.Persist.Class.PersistConfig

Associated Types

type PersistConfigBackend (Either c1 c2) :: (Type -> Type) -> Type -> Type

type PersistConfigPool (Either c1 c2)

Methods

loadConfig :: Value -> Parser (Either c1 c2)

applyEnv :: Either c1 c2 -> IO (Either c1 c2)

createPoolConfig :: Either c1 c2 -> IO (PersistConfigPool (Either c1 c2))

runPool :: MonadUnliftIO m => Either c1 c2 -> PersistConfigBackend (Either c1 c2) m a -> PersistConfigPool (Either c1 c2) -> m a

type family PersistConfigBackend c :: (Type -> Type) -> Type -> Type

Instances

type PersistConfigBackend (Either c1 c2)

Defined in Database.Persist.Class.PersistConfig

type PersistConfigBackend (Either c1 c2) = PersistConfigBackend c1

type family PersistConfigPool c

Instances

type PersistConfigPool (Either c1 c2)

Defined in Database.Persist.Class.PersistConfig

type PersistConfigPool (Either c1 c2) = PersistConfigPool c1

newtype ConstraintNameHS

An ConstraintNameHS represents the Haskell-side name that persistent will use for a constraint.

Since: persistent-2.12.0.0

Constructors

ConstraintNameHS

Fields

• unConstraintNameHS :: Text

Instances

Read ConstraintNameHS

Defined in Database.Persist.Names

Methods

readsPrec :: Int -> ReadS ConstraintNameHS

readList :: ReadS [ConstraintNameHS]

readPrec :: ReadPrec ConstraintNameHS

readListPrec :: ReadPrec [ConstraintNameHS]

Show ConstraintNameHS

Defined in Database.Persist.Names

Methods

showsPrec :: Int -> ConstraintNameHS -> ShowS

show :: ConstraintNameHS -> String

showList :: [ConstraintNameHS] -> ShowS

Eq ConstraintNameHS

Defined in Database.Persist.Names

Methods

(==) :: ConstraintNameHS -> ConstraintNameHS -> Bool

(/=) :: ConstraintNameHS -> ConstraintNameHS -> Bool

Ord ConstraintNameHS

Defined in Database.Persist.Names

Methods

compare :: ConstraintNameHS -> ConstraintNameHS -> Ordering

(<) :: ConstraintNameHS -> ConstraintNameHS -> Bool

(<=) :: ConstraintNameHS -> ConstraintNameHS -> Bool

(>) :: ConstraintNameHS -> ConstraintNameHS -> Bool

(>=) :: ConstraintNameHS -> ConstraintNameHS -> Bool

max :: ConstraintNameHS -> ConstraintNameHS -> ConstraintNameHS

min :: ConstraintNameHS -> ConstraintNameHS -> ConstraintNameHS

Lift ConstraintNameHS

Defined in Database.Persist.Names

Methods

lift :: Quote m => ConstraintNameHS -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => ConstraintNameHS -> Code m ConstraintNameHS

newtype ConstraintNameDB

A ConstraintNameDB represents the datastore-side name that persistent will use for a constraint.

Since: persistent-2.12.0.0

Constructors

ConstraintNameDB

Fields

• unConstraintNameDB :: Text

Instances

Read ConstraintNameDB

Defined in Database.Persist.Names

Methods

readsPrec :: Int -> ReadS ConstraintNameDB

readList :: ReadS [ConstraintNameDB]

readPrec :: ReadPrec ConstraintNameDB

readListPrec :: ReadPrec [ConstraintNameDB]

Show ConstraintNameDB

Defined in Database.Persist.Names

Methods

showsPrec :: Int -> ConstraintNameDB -> ShowS

show :: ConstraintNameDB -> String

showList :: [ConstraintNameDB] -> ShowS

Eq ConstraintNameDB

Defined in Database.Persist.Names

Methods

(==) :: ConstraintNameDB -> ConstraintNameDB -> Bool

(/=) :: ConstraintNameDB -> ConstraintNameDB -> Bool

Ord ConstraintNameDB

Defined in Database.Persist.Names

Methods

compare :: ConstraintNameDB -> ConstraintNameDB -> Ordering

(<) :: ConstraintNameDB -> ConstraintNameDB -> Bool

(<=) :: ConstraintNameDB -> ConstraintNameDB -> Bool

(>) :: ConstraintNameDB -> ConstraintNameDB -> Bool

(>=) :: ConstraintNameDB -> ConstraintNameDB -> Bool

max :: ConstraintNameDB -> ConstraintNameDB -> ConstraintNameDB

min :: ConstraintNameDB -> ConstraintNameDB -> ConstraintNameDB

DatabaseName ConstraintNameDB

Since: persistent-2.12.0.0

Defined in Database.Persist.Names

Methods

escapeWith :: (Text -> str) -> ConstraintNameDB -> str

Lift ConstraintNameDB

Defined in Database.Persist.Names

Methods

lift :: Quote m => ConstraintNameDB -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => ConstraintNameDB -> Code m ConstraintNameDB

newtype EntityNameDB

An EntityNameDB represents the datastore-side name that persistent will use for an entity.

Since: persistent-2.12.0.0

Constructors

EntityNameDB

Fields

• unEntityNameDB :: Text

Instances

Read EntityNameDB

Defined in Database.Persist.Names

Methods

readsPrec :: Int -> ReadS EntityNameDB

readList :: ReadS [EntityNameDB]

readPrec :: ReadPrec EntityNameDB

readListPrec :: ReadPrec [EntityNameDB]

Show EntityNameDB

Defined in Database.Persist.Names

Methods

showsPrec :: Int -> EntityNameDB -> ShowS

show :: EntityNameDB -> String

showList :: [EntityNameDB] -> ShowS

Eq EntityNameDB

Defined in Database.Persist.Names

Methods

(==) :: EntityNameDB -> EntityNameDB -> Bool

(/=) :: EntityNameDB -> EntityNameDB -> Bool

Ord EntityNameDB

Defined in Database.Persist.Names

Methods

compare :: EntityNameDB -> EntityNameDB -> Ordering

(<) :: EntityNameDB -> EntityNameDB -> Bool

(<=) :: EntityNameDB -> EntityNameDB -> Bool

(>) :: EntityNameDB -> EntityNameDB -> Bool

(>=) :: EntityNameDB -> EntityNameDB -> Bool

max :: EntityNameDB -> EntityNameDB -> EntityNameDB

min :: EntityNameDB -> EntityNameDB -> EntityNameDB

DatabaseName EntityNameDB

Defined in Database.Persist.Names

Methods

escapeWith :: (Text -> str) -> EntityNameDB -> str

Lift EntityNameDB

Defined in Database.Persist.Names

Methods

lift :: Quote m => EntityNameDB -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => EntityNameDB -> Code m EntityNameDB

newtype EntityNameHS

An EntityNameHS represents the Haskell-side name that persistent will use for an entity.

Since: persistent-2.12.0.0

Constructors

EntityNameHS

Fields

• unEntityNameHS :: Text

Instances

Read EntityNameHS

Defined in Database.Persist.Names

Methods

readsPrec :: Int -> ReadS EntityNameHS

readList :: ReadS [EntityNameHS]

readPrec :: ReadPrec EntityNameHS

readListPrec :: ReadPrec [EntityNameHS]

Show EntityNameHS

Defined in Database.Persist.Names

Methods

showsPrec :: Int -> EntityNameHS -> ShowS

show :: EntityNameHS -> String

showList :: [EntityNameHS] -> ShowS

Eq EntityNameHS

Defined in Database.Persist.Names

Methods

(==) :: EntityNameHS -> EntityNameHS -> Bool

(/=) :: EntityNameHS -> EntityNameHS -> Bool

Ord EntityNameHS

Defined in Database.Persist.Names

Methods

compare :: EntityNameHS -> EntityNameHS -> Ordering

(<) :: EntityNameHS -> EntityNameHS -> Bool

(<=) :: EntityNameHS -> EntityNameHS -> Bool

(>) :: EntityNameHS -> EntityNameHS -> Bool

(>=) :: EntityNameHS -> EntityNameHS -> Bool

max :: EntityNameHS -> EntityNameHS -> EntityNameHS

min :: EntityNameHS -> EntityNameHS -> EntityNameHS

Lift EntityNameHS

Defined in Database.Persist.Names

Methods

lift :: Quote m => EntityNameHS -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => EntityNameHS -> Code m EntityNameHS

newtype FieldNameHS

A FieldNameHS represents the Haskell-side name that persistent will use for a field.

Since: persistent-2.12.0.0

Constructors

FieldNameHS

Fields

• unFieldNameHS :: Text

Instances

Read FieldNameHS

Defined in Database.Persist.Names

Methods

readsPrec :: Int -> ReadS FieldNameHS

readList :: ReadS [FieldNameHS]

readPrec :: ReadPrec FieldNameHS

readListPrec :: ReadPrec [FieldNameHS]

Show FieldNameHS

Defined in Database.Persist.Names

Methods

showsPrec :: Int -> FieldNameHS -> ShowS

show :: FieldNameHS -> String

showList :: [FieldNameHS] -> ShowS

Eq FieldNameHS

Defined in Database.Persist.Names

Methods

(==) :: FieldNameHS -> FieldNameHS -> Bool

(/=) :: FieldNameHS -> FieldNameHS -> Bool

Ord FieldNameHS

Defined in Database.Persist.Names

Methods

compare :: FieldNameHS -> FieldNameHS -> Ordering

(<) :: FieldNameHS -> FieldNameHS -> Bool

(<=) :: FieldNameHS -> FieldNameHS -> Bool

(>) :: FieldNameHS -> FieldNameHS -> Bool

(>=) :: FieldNameHS -> FieldNameHS -> Bool

max :: FieldNameHS -> FieldNameHS -> FieldNameHS

min :: FieldNameHS -> FieldNameHS -> FieldNameHS

Lift FieldNameHS

Defined in Database.Persist.Names

Methods

lift :: Quote m => FieldNameHS -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => FieldNameHS -> Code m FieldNameHS

newtype FieldNameDB

A FieldNameDB represents the datastore-side name that persistent will use for a field.

Since: persistent-2.12.0.0

Constructors

FieldNameDB

Fields

• unFieldNameDB :: Text

Instances

Read FieldNameDB

Defined in Database.Persist.Names

Methods

readsPrec :: Int -> ReadS FieldNameDB

readList :: ReadS [FieldNameDB]

readPrec :: ReadPrec FieldNameDB

readListPrec :: ReadPrec [FieldNameDB]

Show FieldNameDB

Defined in Database.Persist.Names

Methods

showsPrec :: Int -> FieldNameDB -> ShowS

show :: FieldNameDB -> String

showList :: [FieldNameDB] -> ShowS

Eq FieldNameDB

Defined in Database.Persist.Names

Methods

(==) :: FieldNameDB -> FieldNameDB -> Bool

(/=) :: FieldNameDB -> FieldNameDB -> Bool

Ord FieldNameDB

Defined in Database.Persist.Names

Methods

compare :: FieldNameDB -> FieldNameDB -> Ordering

(<) :: FieldNameDB -> FieldNameDB -> Bool

(<=) :: FieldNameDB -> FieldNameDB -> Bool

(>) :: FieldNameDB -> FieldNameDB -> Bool

(>=) :: FieldNameDB -> FieldNameDB -> Bool

max :: FieldNameDB -> FieldNameDB -> FieldNameDB

min :: FieldNameDB -> FieldNameDB -> FieldNameDB

DatabaseName FieldNameDB

Since: persistent-2.12.0.0

Defined in Database.Persist.Names

Methods

escapeWith :: (Text -> str) -> FieldNameDB -> str

Lift FieldNameDB

Defined in Database.Persist.Names

Methods

lift :: Quote m => FieldNameDB -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => FieldNameDB -> Code m FieldNameDB

class DatabaseName a where

Convenience operations for working with '-NameDB' types.

Since: persistent-2.12.0.0

Methods

escapeWith :: (Text -> str) -> a -> str

Instances

DatabaseName ConstraintNameDB

Since: persistent-2.12.0.0

Defined in Database.Persist.Names

Methods

escapeWith :: (Text -> str) -> ConstraintNameDB -> str

DatabaseName EntityNameDB

Defined in Database.Persist.Names

Methods

escapeWith :: (Text -> str) -> EntityNameDB -> str

DatabaseName FieldNameDB

Since: persistent-2.12.0.0

Defined in Database.Persist.Names

Methods

escapeWith :: (Text -> str) -> FieldNameDB -> str

data LiteralType

A type that determines how a backend should handle the literal.

Since: persistent-2.12.0.0

Constructors

Escaped

The accompanying value will be escaped before inserting into the database. This is the correct default choice to use.

Since: persistent-2.12.0.0

Unescaped

The accompanying value will not be escaped when inserting into the database. This is potentially dangerous - use this with care.

Since: persistent-2.12.0.0

DbSpecific

The DbSpecific constructor corresponds to the legacy PersistDbSpecific constructor. We need to keep this around because old databases may have serialized JSON representations that reference this. We don't want to break the ability of a database to load rows.

Since: persistent-2.12.0.0

Instances

Read LiteralType

Defined in Database.Persist.PersistValue

Methods

readsPrec :: Int -> ReadS LiteralType

readList :: ReadS [LiteralType]

readPrec :: ReadPrec LiteralType

readListPrec :: ReadPrec [LiteralType]

Show LiteralType

Defined in Database.Persist.PersistValue

Methods

showsPrec :: Int -> LiteralType -> ShowS

show :: LiteralType -> String

showList :: [LiteralType] -> ShowS

Eq LiteralType

Defined in Database.Persist.PersistValue

Methods

(==) :: LiteralType -> LiteralType -> Bool

(/=) :: LiteralType -> LiteralType -> Bool

Ord LiteralType

Defined in Database.Persist.PersistValue

Methods

compare :: LiteralType -> LiteralType -> Ordering

(<) :: LiteralType -> LiteralType -> Bool

(<=) :: LiteralType -> LiteralType -> Bool

(>) :: LiteralType -> LiteralType -> Bool

(>=) :: LiteralType -> LiteralType -> Bool

max :: LiteralType -> LiteralType -> LiteralType

min :: LiteralType -> LiteralType -> LiteralType

data PersistValue

A raw value which can be stored in any backend and can be marshalled to and from a PersistField.

Constructors

PersistText Text

PersistByteString ByteString

PersistInt64 Int64

PersistDouble Double

PersistRational Rational

PersistBool Bool

PersistDay Day

PersistTimeOfDay TimeOfDay

PersistUTCTime UTCTime

PersistNull

PersistList [PersistValue]

PersistMap [(Text, PersistValue)]

PersistObjectId ByteString

Intended especially for MongoDB backend

PersistArray [PersistValue]

Intended especially for PostgreSQL backend for text arrays

PersistLiteral_ LiteralType ByteString

This constructor is used to specify some raw literal value for the backend. The LiteralType value specifies how the value should be escaped. This can be used to make special, custom types avaialable in the back end.

Since: persistent-2.12.0.0

Bundled Patterns

pattern PersistLiteral :: ByteString -> PersistValue

This pattern synonym used to be a data constructor on PersistValue, but was changed into a catch-all pattern synonym to allow backwards compatiblity with database types. See the documentation on PersistDbSpecific for more details.

Since: persistent-2.12.0.0

pattern PersistLiteralEscaped :: ByteString -> PersistValue

This pattern synonym used to be a data constructor on PersistValue, but was changed into a catch-all pattern synonym to allow backwards compatiblity with database types. See the documentation on PersistDbSpecific for more details.

Since: persistent-2.12.0.0

pattern PersistDbSpecific :: ByteString -> PersistValue

This pattern synonym used to be a data constructor for the PersistValue type. It was changed to be a pattern so that JSON-encoded database values could be parsed into their corresponding values. You should not use this, and instead prefer to pattern match on PersistLiteral_ directly.

If you use this, it will overlap a patern match on the 'PersistLiteral_, PersistLiteral, and PersistLiteralEscaped patterns. If you need to disambiguate between these constructors, pattern match on PersistLiteral_ directly.

Since: persistent-2.12.0.0

Instances

FromJSON PersistValue

Defined in Database.Persist.PersistValue

Methods

parseJSON :: Value -> Parser PersistValue

parseJSONList :: Value -> Parser [PersistValue]

omittedField :: Maybe PersistValue

ToJSON PersistValue

Defined in Database.Persist.PersistValue

Methods

toJSON :: PersistValue -> Value

toEncoding :: PersistValue -> Encoding

toJSONList :: [PersistValue] -> Value

toEncodingList :: [PersistValue] -> Encoding

omitField :: PersistValue -> Bool

Read PersistValue

Defined in Database.Persist.PersistValue

Methods

readsPrec :: Int -> ReadS PersistValue

readList :: ReadS [PersistValue]

readPrec :: ReadPrec PersistValue

readListPrec :: ReadPrec [PersistValue]

Show PersistValue

Defined in Database.Persist.PersistValue

Methods

showsPrec :: Int -> PersistValue -> ShowS

show :: PersistValue -> String

showList :: [PersistValue] -> ShowS

NFData PersistValue

Since: persistent-2.14.4.0

Defined in Database.Persist.PersistValue

Methods

rnf :: PersistValue -> ()

Eq PersistValue

Defined in Database.Persist.PersistValue

Methods

(==) :: PersistValue -> PersistValue -> Bool

(/=) :: PersistValue -> PersistValue -> Bool

Ord PersistValue

Defined in Database.Persist.PersistValue

Methods

compare :: PersistValue -> PersistValue -> Ordering

(<) :: PersistValue -> PersistValue -> Bool

(<=) :: PersistValue -> PersistValue -> Bool

(>) :: PersistValue -> PersistValue -> Bool

(>=) :: PersistValue -> PersistValue -> Bool

max :: PersistValue -> PersistValue -> PersistValue

min :: PersistValue -> PersistValue -> PersistValue

FromHttpApiData PersistValue

Defined in Database.Persist.PersistValue

Methods

parseUrlPiece :: Text -> Either Text PersistValue

parseHeader :: ByteString -> Either Text PersistValue

parseQueryParam :: Text -> Either Text PersistValue

ToHttpApiData PersistValue

Defined in Database.Persist.PersistValue

Methods

toUrlPiece :: PersistValue -> Text

toEncodedUrlPiece :: PersistValue -> Builder

toHeader :: PersistValue -> ByteString

toQueryParam :: PersistValue -> Text

toEncodedQueryParam :: PersistValue -> Builder

PathPiece PersistValue

Defined in Database.Persist.PersistValue

Methods

fromPathPiece :: Text -> Maybe PersistValue

toPathPiece :: PersistValue -> Text

PersistField PersistValue

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: PersistValue -> PersistValue

fromPersistValue :: PersistValue -> Either Text PersistValue

PersistFieldSql PersistValue

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy PersistValue -> SqlType

data IsolationLevel

Please refer to the documentation for the database in question for a full overview of the semantics of the varying isloation levels

Constructors

ReadUncommitted

ReadCommitted

RepeatableRead

Serializable

Instances

Bounded IsolationLevel

Defined in Database.Persist.SqlBackend.Internal.IsolationLevel

Methods

minBound :: IsolationLevel

maxBound :: IsolationLevel

Enum IsolationLevel

Defined in Database.Persist.SqlBackend.Internal.IsolationLevel

Methods

succ :: IsolationLevel -> IsolationLevel

pred :: IsolationLevel -> IsolationLevel

toEnum :: Int -> IsolationLevel

fromEnum :: IsolationLevel -> Int

enumFrom :: IsolationLevel -> [IsolationLevel]

enumFromThen :: IsolationLevel -> IsolationLevel -> [IsolationLevel]

enumFromTo :: IsolationLevel -> IsolationLevel -> [IsolationLevel]

enumFromThenTo :: IsolationLevel -> IsolationLevel -> IsolationLevel -> [IsolationLevel]

Show IsolationLevel

Defined in Database.Persist.SqlBackend.Internal.IsolationLevel

Methods

showsPrec :: Int -> IsolationLevel -> ShowS

show :: IsolationLevel -> String

showList :: [IsolationLevel] -> ShowS

Eq IsolationLevel

Defined in Database.Persist.SqlBackend.Internal.IsolationLevel

Methods

(==) :: IsolationLevel -> IsolationLevel -> Bool

(/=) :: IsolationLevel -> IsolationLevel -> Bool

Ord IsolationLevel

Defined in Database.Persist.SqlBackend.Internal.IsolationLevel

Methods

compare :: IsolationLevel -> IsolationLevel -> Ordering

(<) :: IsolationLevel -> IsolationLevel -> Bool

(<=) :: IsolationLevel -> IsolationLevel -> Bool

(>) :: IsolationLevel -> IsolationLevel -> Bool

(>=) :: IsolationLevel -> IsolationLevel -> Bool

max :: IsolationLevel -> IsolationLevel -> IsolationLevel

min :: IsolationLevel -> IsolationLevel -> IsolationLevel

data FieldDef

A FieldDef represents the inormation that persistent knows about a field of a datatype. This includes information used to parse the field out of the database and what the field corresponds to.

Constructors

FieldDef

Fields

• fieldHaskell :: !FieldNameHS

  The name of the field. Note that this does not corresponds to the record labels generated for the particular entity - record labels are generated with the type name prefixed to the field, so a FieldDef that contains a FieldNameHS "name" for a type User will have a record field userName.

• fieldDB :: !FieldNameDB

  The name of the field in the database. For SQL databases, this corresponds to the column name.

• fieldType :: !FieldType

  The type of the field in Haskell.

• fieldSqlType :: !SqlType

  The type of the field in a SQL database.

• fieldAttrs :: ![FieldAttr]

  User annotations for a field. These are provided with the ! operator.

• fieldStrict :: !Bool

  If this is True, then the Haskell datatype will have a strict record field. The default value for this is True.

• fieldReference :: !ReferenceDef
• fieldCascade :: !FieldCascade

  Defines how operations on the field cascade on to the referenced tables. This doesn't have any meaning if the fieldReference is set to NoReference or SelfReference. The cascade option here should be the same as the one obtained in the fieldReference.

  Since: persistent-2.11.0

• fieldComments :: !(Maybe Text)

  Optional comments for a Field.

  Since: persistent-2.10.0

• fieldGenerated :: !(Maybe Text)

  Whether or not the field is a GENERATED column, and additionally the expression to use for generation.

  Since: persistent-2.11.0.0

• fieldIsImplicitIdColumn :: !Bool

  True if the field is an implicit ID column. False otherwise.

  Since: persistent-2.13.0.0

Instances

Read FieldDef

Defined in Database.Persist.Types.Base

Methods

readsPrec :: Int -> ReadS FieldDef

readList :: ReadS [FieldDef]

readPrec :: ReadPrec FieldDef

readListPrec :: ReadPrec [FieldDef]

Show FieldDef

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> FieldDef -> ShowS

show :: FieldDef -> String

showList :: [FieldDef] -> ShowS

Eq FieldDef

Defined in Database.Persist.Types.Base

Methods

(==) :: FieldDef -> FieldDef -> Bool

(/=) :: FieldDef -> FieldDef -> Bool

Ord FieldDef

Defined in Database.Persist.Types.Base

Methods

compare :: FieldDef -> FieldDef -> Ordering

(<) :: FieldDef -> FieldDef -> Bool

(<=) :: FieldDef -> FieldDef -> Bool

(>) :: FieldDef -> FieldDef -> Bool

(>=) :: FieldDef -> FieldDef -> Bool

max :: FieldDef -> FieldDef -> FieldDef

min :: FieldDef -> FieldDef -> FieldDef

Lift FieldDef

Defined in Database.Persist.Types.Base

Methods

lift :: Quote m => FieldDef -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => FieldDef -> Code m FieldDef

data PersistUpdate

Constructors

Assign

Add

Subtract

Multiply

Divide

BackendSpecificUpdate Text

Instances

Read PersistUpdate

Defined in Database.Persist.Types.Base

Methods

readsPrec :: Int -> ReadS PersistUpdate

readList :: ReadS [PersistUpdate]

readPrec :: ReadPrec PersistUpdate

readListPrec :: ReadPrec [PersistUpdate]

Show PersistUpdate

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> PersistUpdate -> ShowS

show :: PersistUpdate -> String

showList :: [PersistUpdate] -> ShowS

Lift PersistUpdate

Defined in Database.Persist.Types.Base

Methods

lift :: Quote m => PersistUpdate -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => PersistUpdate -> Code m PersistUpdate

type family BackendSpecificUpdate backend record

data UpdateException

Constructors

KeyNotFound String

UpsertError String

Instances

Exception UpdateException

Defined in Database.Persist.Types.Base

Methods

toException :: UpdateException -> SomeException

fromException :: SomeException -> Maybe UpdateException

displayException :: UpdateException -> String

Show UpdateException

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> UpdateException -> ShowS

show :: UpdateException -> String

showList :: [UpdateException] -> ShowS

data PersistFilter

Constructors

Eq

Ne

Gt

Lt

Ge

Le

In

NotIn

Instances

Read PersistFilter

Defined in Database.Persist.Types.Base

Methods

readsPrec :: Int -> ReadS PersistFilter

readList :: ReadS [PersistFilter]

readPrec :: ReadPrec PersistFilter

readListPrec :: ReadPrec [PersistFilter]

Show PersistFilter

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> PersistFilter -> ShowS

show :: PersistFilter -> String

showList :: [PersistFilter] -> ShowS

Lift PersistFilter

Defined in Database.Persist.Types.Base

Methods

lift :: Quote m => PersistFilter -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => PersistFilter -> Code m PersistFilter

data SqlType

A SQL data type. Naming attempts to reflect the underlying Haskell datatypes, eg SqlString instead of SqlVarchar. Different SQL databases may have different translations for these types.

Constructors

SqlString

SqlInt32

SqlInt64

SqlReal

SqlNumeric Word32 Word32

SqlBool

SqlDay

SqlTime

SqlDayTime

Always uses UTC timezone

SqlBlob

SqlOther Text

a backend-specific name

Instances

Read SqlType

Defined in Database.Persist.Types.Base

Methods

readsPrec :: Int -> ReadS SqlType

readList :: ReadS [SqlType]

readPrec :: ReadPrec SqlType

readListPrec :: ReadPrec [SqlType]

Show SqlType

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> SqlType -> ShowS

show :: SqlType -> String

showList :: [SqlType] -> ShowS

Eq SqlType

Defined in Database.Persist.Types.Base

Methods

(==) :: SqlType -> SqlType -> Bool

(/=) :: SqlType -> SqlType -> Bool

Ord SqlType

Defined in Database.Persist.Types.Base

Methods

compare :: SqlType -> SqlType -> Ordering

(<) :: SqlType -> SqlType -> Bool

(<=) :: SqlType -> SqlType -> Bool

(>) :: SqlType -> SqlType -> Bool

(>=) :: SqlType -> SqlType -> Bool

max :: SqlType -> SqlType -> SqlType

min :: SqlType -> SqlType -> SqlType

Lift SqlType

Defined in Database.Persist.Types.Base

Methods

lift :: Quote m => SqlType -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => SqlType -> Code m SqlType

data PersistException

Constructors

PersistError Text

Generic Exception

PersistMarshalError Text

PersistInvalidField Text

PersistForeignConstraintUnmet Text

PersistMongoDBError Text

PersistMongoDBUnsupported Text

Instances

Exception PersistException

Defined in Database.Persist.Types.Base

Methods

toException :: PersistException -> SomeException

fromException :: SomeException -> Maybe PersistException

displayException :: PersistException -> String

Show PersistException

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> PersistException -> ShowS

show :: PersistException -> String

showList :: [PersistException] -> ShowS

data CascadeAction

An action that might happen on a deletion or update on a foreign key change.

Since: persistent-2.11.0

Constructors

Cascade

Restrict

SetNull

SetDefault

Instances

Read CascadeAction

Defined in Database.Persist.Types.Base

Methods

readsPrec :: Int -> ReadS CascadeAction

readList :: ReadS [CascadeAction]

readPrec :: ReadPrec CascadeAction

readListPrec :: ReadPrec [CascadeAction]

Show CascadeAction

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> CascadeAction -> ShowS

show :: CascadeAction -> String

showList :: [CascadeAction] -> ShowS

Eq CascadeAction

Defined in Database.Persist.Types.Base

Methods

(==) :: CascadeAction -> CascadeAction -> Bool

(/=) :: CascadeAction -> CascadeAction -> Bool

Ord CascadeAction

Defined in Database.Persist.Types.Base

Methods

compare :: CascadeAction -> CascadeAction -> Ordering

(<) :: CascadeAction -> CascadeAction -> Bool

(<=) :: CascadeAction -> CascadeAction -> Bool

(>) :: CascadeAction -> CascadeAction -> Bool

(>=) :: CascadeAction -> CascadeAction -> Bool

max :: CascadeAction -> CascadeAction -> CascadeAction

min :: CascadeAction -> CascadeAction -> CascadeAction

Lift CascadeAction

Defined in Database.Persist.Types.Base

Methods

lift :: Quote m => CascadeAction -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => CascadeAction -> Code m CascadeAction

data FieldCascade

This datatype describes how a foreign reference field cascades deletes or updates.

This type is used in both parsing the model definitions and performing migrations. A Nothing in either of the field values means that the user has not specified a CascadeAction. An unspecified CascadeAction is defaulted to Restrict when doing migrations.

Since: persistent-2.11.0

Constructors

FieldCascade

Fields

• fcOnUpdate :: !(Maybe CascadeAction)
• fcOnDelete :: !(Maybe CascadeAction)

Instances

Read FieldCascade

Defined in Database.Persist.Types.Base

Methods

readsPrec :: Int -> ReadS FieldCascade

readList :: ReadS [FieldCascade]

readPrec :: ReadPrec FieldCascade

readListPrec :: ReadPrec [FieldCascade]

Show FieldCascade

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> FieldCascade -> ShowS

show :: FieldCascade -> String

showList :: [FieldCascade] -> ShowS

Eq FieldCascade

Defined in Database.Persist.Types.Base

Methods

(==) :: FieldCascade -> FieldCascade -> Bool

(/=) :: FieldCascade -> FieldCascade -> Bool

Ord FieldCascade

Defined in Database.Persist.Types.Base

Methods

compare :: FieldCascade -> FieldCascade -> Ordering

(<) :: FieldCascade -> FieldCascade -> Bool

(<=) :: FieldCascade -> FieldCascade -> Bool

(>) :: FieldCascade -> FieldCascade -> Bool

(>=) :: FieldCascade -> FieldCascade -> Bool

max :: FieldCascade -> FieldCascade -> FieldCascade

min :: FieldCascade -> FieldCascade -> FieldCascade

Lift FieldCascade

Defined in Database.Persist.Types.Base

Methods

lift :: Quote m => FieldCascade -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => FieldCascade -> Code m FieldCascade

data ForeignDef

Constructors

ForeignDef

Fields

• foreignRefTableHaskell :: !EntityNameHS
• foreignRefTableDBName :: !EntityNameDB
• foreignConstraintNameHaskell :: !ConstraintNameHS
• foreignConstraintNameDBName :: !ConstraintNameDB
• foreignFieldCascade :: !FieldCascade

  Determine how the field will cascade on updates and deletions.

  Since: persistent-2.11.0

• foreignFields :: ![(ForeignFieldDef, ForeignFieldDef)]
• foreignAttrs :: ![Attr]
• foreignNullable :: Bool
• foreignToPrimary :: Bool

  Determines if the reference is towards a Primary Key or not.

  Since: persistent-2.11.0

Instances

Read ForeignDef

Defined in Database.Persist.Types.Base

Methods

readsPrec :: Int -> ReadS ForeignDef

readList :: ReadS [ForeignDef]

readPrec :: ReadPrec ForeignDef

readListPrec :: ReadPrec [ForeignDef]

Show ForeignDef

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> ForeignDef -> ShowS

show :: ForeignDef -> String

showList :: [ForeignDef] -> ShowS

Eq ForeignDef

Defined in Database.Persist.Types.Base

Methods

(==) :: ForeignDef -> ForeignDef -> Bool

(/=) :: ForeignDef -> ForeignDef -> Bool

Ord ForeignDef

Defined in Database.Persist.Types.Base

Methods

compare :: ForeignDef -> ForeignDef -> Ordering

(<) :: ForeignDef -> ForeignDef -> Bool

(<=) :: ForeignDef -> ForeignDef -> Bool

(>) :: ForeignDef -> ForeignDef -> Bool

(>=) :: ForeignDef -> ForeignDef -> Bool

max :: ForeignDef -> ForeignDef -> ForeignDef

min :: ForeignDef -> ForeignDef -> ForeignDef

Lift ForeignDef

Defined in Database.Persist.Types.Base

Methods

lift :: Quote m => ForeignDef -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => ForeignDef -> Code m ForeignDef

type ForeignFieldDef = (FieldNameHS, FieldNameDB)

Used instead of FieldDef to generate a smaller amount of code

data CompositeDef

Constructors

CompositeDef

Fields

• compositeFields :: !(NonEmpty FieldDef)
• compositeAttrs :: ![Attr]

Instances

Read CompositeDef

Defined in Database.Persist.Types.Base

Methods

readsPrec :: Int -> ReadS CompositeDef

readList :: ReadS [CompositeDef]

readPrec :: ReadPrec CompositeDef

readListPrec :: ReadPrec [CompositeDef]

Show CompositeDef

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> CompositeDef -> ShowS

show :: CompositeDef -> String

showList :: [CompositeDef] -> ShowS

Eq CompositeDef

Defined in Database.Persist.Types.Base

Methods

(==) :: CompositeDef -> CompositeDef -> Bool

(/=) :: CompositeDef -> CompositeDef -> Bool

Ord CompositeDef

Defined in Database.Persist.Types.Base

Methods

compare :: CompositeDef -> CompositeDef -> Ordering

(<) :: CompositeDef -> CompositeDef -> Bool

(<=) :: CompositeDef -> CompositeDef -> Bool

(>) :: CompositeDef -> CompositeDef -> Bool

(>=) :: CompositeDef -> CompositeDef -> Bool

max :: CompositeDef -> CompositeDef -> CompositeDef

min :: CompositeDef -> CompositeDef -> CompositeDef

Lift CompositeDef

Defined in Database.Persist.Types.Base

Methods

lift :: Quote m => CompositeDef -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => CompositeDef -> Code m CompositeDef

data UniqueDef

Type for storing the Uniqueness constraint in the Schema. Assume you have the following schema with a uniqueness constraint:

Person
  name String
  age Int
  UniqueAge age

This will be represented as:

UniqueDef
    { uniqueHaskell = ConstraintNameHS (packPTH UniqueAge)
    , uniqueDBName = ConstraintNameDB (packPTH "unique_age")
    , uniqueFields = [(FieldNameHS (packPTH "age"), FieldNameDB (packPTH "age"))]
    , uniqueAttrs = []
    }

Constructors

UniqueDef

Fields

• uniqueHaskell :: !ConstraintNameHS
• uniqueDBName :: !ConstraintNameDB
• uniqueFields :: !(NonEmpty (FieldNameHS, FieldNameDB))
• uniqueAttrs :: ![Attr]

Instances

Read UniqueDef

Defined in Database.Persist.Types.Base

Methods

readsPrec :: Int -> ReadS UniqueDef

readList :: ReadS [UniqueDef]

readPrec :: ReadPrec UniqueDef

readListPrec :: ReadPrec [UniqueDef]

Show UniqueDef

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> UniqueDef -> ShowS

show :: UniqueDef -> String

showList :: [UniqueDef] -> ShowS

Eq UniqueDef

Defined in Database.Persist.Types.Base

Methods

(==) :: UniqueDef -> UniqueDef -> Bool

(/=) :: UniqueDef -> UniqueDef -> Bool

Ord UniqueDef

Defined in Database.Persist.Types.Base

Methods

compare :: UniqueDef -> UniqueDef -> Ordering

(<) :: UniqueDef -> UniqueDef -> Bool

(<=) :: UniqueDef -> UniqueDef -> Bool

(>) :: UniqueDef -> UniqueDef -> Bool

(>=) :: UniqueDef -> UniqueDef -> Bool

max :: UniqueDef -> UniqueDef -> UniqueDef

min :: UniqueDef -> UniqueDef -> UniqueDef

Lift UniqueDef

Defined in Database.Persist.Types.Base

Methods

lift :: Quote m => UniqueDef -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => UniqueDef -> Code m UniqueDef

data EmbedFieldDef

An EmbedFieldDef is the same as a FieldDef But it is only used for embeddedFields so it only has data needed for embedding

Constructors

EmbedFieldDef

Fields

• emFieldDB :: FieldNameDB
• emFieldEmbed :: Maybe (Either SelfEmbed EntityNameHS)

Instances

Read EmbedFieldDef

Defined in Database.Persist.Types.Base

Methods

readsPrec :: Int -> ReadS EmbedFieldDef

readList :: ReadS [EmbedFieldDef]

readPrec :: ReadPrec EmbedFieldDef

readListPrec :: ReadPrec [EmbedFieldDef]

Show EmbedFieldDef

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> EmbedFieldDef -> ShowS

show :: EmbedFieldDef -> String

showList :: [EmbedFieldDef] -> ShowS

Eq EmbedFieldDef

Defined in Database.Persist.Types.Base

Methods

(==) :: EmbedFieldDef -> EmbedFieldDef -> Bool

(/=) :: EmbedFieldDef -> EmbedFieldDef -> Bool

Ord EmbedFieldDef

Defined in Database.Persist.Types.Base

Methods

compare :: EmbedFieldDef -> EmbedFieldDef -> Ordering

(<) :: EmbedFieldDef -> EmbedFieldDef -> Bool

(<=) :: EmbedFieldDef -> EmbedFieldDef -> Bool

(>) :: EmbedFieldDef -> EmbedFieldDef -> Bool

(>=) :: EmbedFieldDef -> EmbedFieldDef -> Bool

max :: EmbedFieldDef -> EmbedFieldDef -> EmbedFieldDef

min :: EmbedFieldDef -> EmbedFieldDef -> EmbedFieldDef

Lift EmbedFieldDef

Defined in Database.Persist.Types.Base

Methods

lift :: Quote m => EmbedFieldDef -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => EmbedFieldDef -> Code m EmbedFieldDef

data EmbedEntityDef

An EmbedEntityDef is the same as an EntityDef But it is only used for fieldReference so it only has data needed for embedding

Constructors

EmbedEntityDef

Fields

• embeddedHaskell :: EntityNameHS
• embeddedFields :: [EmbedFieldDef]

Instances

Read EmbedEntityDef

Defined in Database.Persist.Types.Base

Methods

readsPrec :: Int -> ReadS EmbedEntityDef

readList :: ReadS [EmbedEntityDef]

readPrec :: ReadPrec EmbedEntityDef

readListPrec :: ReadPrec [EmbedEntityDef]

Show EmbedEntityDef

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> EmbedEntityDef -> ShowS

show :: EmbedEntityDef -> String

showList :: [EmbedEntityDef] -> ShowS

Eq EmbedEntityDef

Defined in Database.Persist.Types.Base

Methods

(==) :: EmbedEntityDef -> EmbedEntityDef -> Bool

(/=) :: EmbedEntityDef -> EmbedEntityDef -> Bool

Ord EmbedEntityDef

Defined in Database.Persist.Types.Base

Methods

compare :: EmbedEntityDef -> EmbedEntityDef -> Ordering

(<) :: EmbedEntityDef -> EmbedEntityDef -> Bool

(<=) :: EmbedEntityDef -> EmbedEntityDef -> Bool

(>) :: EmbedEntityDef -> EmbedEntityDef -> Bool

(>=) :: EmbedEntityDef -> EmbedEntityDef -> Bool

max :: EmbedEntityDef -> EmbedEntityDef -> EmbedEntityDef

min :: EmbedEntityDef -> EmbedEntityDef -> EmbedEntityDef

Lift EmbedEntityDef

Defined in Database.Persist.Types.Base

Methods

lift :: Quote m => EmbedEntityDef -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => EmbedEntityDef -> Code m EmbedEntityDef

data ReferenceDef

There are 3 kinds of references 1) composite (to fields that exist in the record) 2) single field 3) embedded

Constructors

NoReference

ForeignRef !EntityNameHS

A ForeignRef has a late binding to the EntityDef it references via name and has the Haskell type of the foreign key in the form of FieldType

EmbedRef EntityNameHS

SelfReference

A SelfReference stops an immediate cycle which causes non-termination at compile-time (issue #311).

Instances

Read ReferenceDef

Defined in Database.Persist.Types.Base

Methods

readsPrec :: Int -> ReadS ReferenceDef

readList :: ReadS [ReferenceDef]

readPrec :: ReadPrec ReferenceDef

readListPrec :: ReadPrec [ReferenceDef]

Show ReferenceDef

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> ReferenceDef -> ShowS

show :: ReferenceDef -> String

showList :: [ReferenceDef] -> ShowS

Eq ReferenceDef

Defined in Database.Persist.Types.Base

Methods

(==) :: ReferenceDef -> ReferenceDef -> Bool

(/=) :: ReferenceDef -> ReferenceDef -> Bool

Ord ReferenceDef

Defined in Database.Persist.Types.Base

Methods

compare :: ReferenceDef -> ReferenceDef -> Ordering

(<) :: ReferenceDef -> ReferenceDef -> Bool

(<=) :: ReferenceDef -> ReferenceDef -> Bool

(>) :: ReferenceDef -> ReferenceDef -> Bool

(>=) :: ReferenceDef -> ReferenceDef -> Bool

max :: ReferenceDef -> ReferenceDef -> ReferenceDef

min :: ReferenceDef -> ReferenceDef -> ReferenceDef

Lift ReferenceDef

Defined in Database.Persist.Types.Base

Methods

lift :: Quote m => ReferenceDef -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => ReferenceDef -> Code m ReferenceDef

data FieldType

A FieldType describes a field parsed from the QuasiQuoter and is used to determine the Haskell type in the generated code.

name Text parses into FTTypeCon Nothing Text

name T.Text parses into FTTypeCon (Just T Text)

name (Jsonb User) parses into:

FTApp (FTTypeCon Nothing Jsonb) (FTTypeCon Nothing User)

Constructors

FTTypeCon (Maybe Text) Text

Optional module and name.

FTLit FieldTypeLit

FTTypePromoted Text

FTApp FieldType FieldType

FTList FieldType

Instances

Read FieldType

Defined in Database.Persist.Types.Base

Methods

readsPrec :: Int -> ReadS FieldType

readList :: ReadS [FieldType]

readPrec :: ReadPrec FieldType

readListPrec :: ReadPrec [FieldType]

Show FieldType

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> FieldType -> ShowS

show :: FieldType -> String

showList :: [FieldType] -> ShowS

Eq FieldType

Defined in Database.Persist.Types.Base

Methods

(==) :: FieldType -> FieldType -> Bool

(/=) :: FieldType -> FieldType -> Bool

Ord FieldType

Defined in Database.Persist.Types.Base

Methods

compare :: FieldType -> FieldType -> Ordering

(<) :: FieldType -> FieldType -> Bool

(<=) :: FieldType -> FieldType -> Bool

(>) :: FieldType -> FieldType -> Bool

(>=) :: FieldType -> FieldType -> Bool

max :: FieldType -> FieldType -> FieldType

min :: FieldType -> FieldType -> FieldType

Lift FieldType

Defined in Database.Persist.Types.Base

Methods

lift :: Quote m => FieldType -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => FieldType -> Code m FieldType

data FieldAttr

Attributes that may be attached to fields that can affect migrations and serialization in backend-specific ways.

While we endeavor to, we can't forsee all use cases for all backends, and so FieldAttr is extensible through its constructor FieldAttrOther.

Since: persistent-2.11.0.0

Constructors

FieldAttrMaybe

The Maybe keyword goes after the type. This indicates that the column is nullable, and the generated Haskell code will have a Maybe type for it.

Example:

User
    name Text Maybe

FieldAttrNullable

This indicates that the column is nullable, but should not have a Maybe type. For this to work out, you need to ensure that the PersistField instance for the type in question can support a PersistNull value.

data What = NoWhat | Hello Text

instance PersistField What where
    fromPersistValue PersistNull =
        pure NoWhat
    fromPersistValue pv =
        Hello $ fromPersistValue pv

instance PersistFieldSql What where
    sqlType _ = SqlString

User
    what What nullable

FieldAttrMigrationOnly

This tag means that the column will not be present on the Haskell code, but will not be removed from the database. Useful to deprecate fields in phases.

You should set the column to be nullable in the database. Otherwise, inserts won't have values.

User
    oldName Text MigrationOnly
    newName Text

FieldAttrSafeToRemove

A SafeToRemove attribute is not present on the Haskell datatype, and the backend migrations should attempt to drop the column without triggering any unsafe migration warnings.

Useful after you've used MigrationOnly to remove a column from the database in phases.

User
    oldName Text SafeToRemove
    newName Text

FieldAttrNoreference

This attribute indicates that we should not create a foreign key reference from a column. By default, persistent will try and create a foreign key reference for a column if it can determine that the type of the column is a Key entity or an EntityId and the Entity's name was present in mkPersist.

This is useful if you want to use the explicit foreign key syntax.

Post
    title    Text

Comment
    postId   PostId      noreference
    Foreign Post fk_comment_post postId

FieldAttrReference Text

This is set to specify precisely the database table the column refers to.

Post
    title    Text

Comment
    postId   PostId references="post"

You should not need this - persistent should be capable of correctly determining the target table's name. If you do need this, please file an issue describing why.

FieldAttrConstraint Text

Specify a name for the constraint on the foreign key reference for this table.

Post
    title    Text

Comment
    postId   PostId constraint="my_cool_constraint_name"

FieldAttrDefault Text

Specify the default value for a column.

User
    createdAt    UTCTime     default="NOW()"

Note that a default= attribute does not mean you can omit the value while inserting.

FieldAttrSqltype Text

Specify a custom SQL type for the column. Generally, you should define a custom datatype with a custom PersistFieldSql instance instead of using this.

User
    uuid     Text    sqltype=UUID

FieldAttrMaxlen Integer

Set a maximum length for a column. Useful for VARCHAR and indexes.

User
    name     Text    maxlen=200

    UniqueName name

FieldAttrSql Text

Specify the database name of the column.

User
    blarghle     Int     sql="b_l_a_r_g_h_l_e"

Useful for performing phased migrations, where one column is renamed to another column over time.

FieldAttrOther Text

A grab bag of random attributes that were unrecognized by the parser.

Instances

Read FieldAttr

Defined in Database.Persist.Types.Base

Methods

readsPrec :: Int -> ReadS FieldAttr

readList :: ReadS [FieldAttr]

readPrec :: ReadPrec FieldAttr

readListPrec :: ReadPrec [FieldAttr]

Show FieldAttr

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> FieldAttr -> ShowS

show :: FieldAttr -> String

showList :: [FieldAttr] -> ShowS

Eq FieldAttr

Defined in Database.Persist.Types.Base

Methods

(==) :: FieldAttr -> FieldAttr -> Bool

(/=) :: FieldAttr -> FieldAttr -> Bool

Ord FieldAttr

Defined in Database.Persist.Types.Base

Methods

compare :: FieldAttr -> FieldAttr -> Ordering

(<) :: FieldAttr -> FieldAttr -> Bool

(<=) :: FieldAttr -> FieldAttr -> Bool

(>) :: FieldAttr -> FieldAttr -> Bool

(>=) :: FieldAttr -> FieldAttr -> Bool

max :: FieldAttr -> FieldAttr -> FieldAttr

min :: FieldAttr -> FieldAttr -> FieldAttr

Lift FieldAttr

Defined in Database.Persist.Types.Base

Methods

lift :: Quote m => FieldAttr -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => FieldAttr -> Code m FieldAttr

type Attr = Text

type ExtraLine = [Text]

data EntityIdDef

The definition for the entity's primary key ID.

Since: persistent-2.13.0.0

Constructors

EntityIdField !FieldDef

The entity has a single key column, and it is a surrogate key - that is, you can't go from rec -> Key rec.

Since: persistent-2.13.0.0

EntityIdNaturalKey !CompositeDef

The entity has a natural key. This means you can write rec -> Key rec because all the key fields are present on the datatype.

A natural key can have one or more columns.

Since: persistent-2.13.0.0

Instances

Read EntityIdDef

Defined in Database.Persist.Types.Base

Methods

readsPrec :: Int -> ReadS EntityIdDef

readList :: ReadS [EntityIdDef]

readPrec :: ReadPrec EntityIdDef

readListPrec :: ReadPrec [EntityIdDef]

Show EntityIdDef

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> EntityIdDef -> ShowS

show :: EntityIdDef -> String

showList :: [EntityIdDef] -> ShowS

Eq EntityIdDef

Defined in Database.Persist.Types.Base

Methods

(==) :: EntityIdDef -> EntityIdDef -> Bool

(/=) :: EntityIdDef -> EntityIdDef -> Bool

Ord EntityIdDef

Defined in Database.Persist.Types.Base

Methods

compare :: EntityIdDef -> EntityIdDef -> Ordering

(<) :: EntityIdDef -> EntityIdDef -> Bool

(<=) :: EntityIdDef -> EntityIdDef -> Bool

(>) :: EntityIdDef -> EntityIdDef -> Bool

(>=) :: EntityIdDef -> EntityIdDef -> Bool

max :: EntityIdDef -> EntityIdDef -> EntityIdDef

min :: EntityIdDef -> EntityIdDef -> EntityIdDef

Lift EntityIdDef

Defined in Database.Persist.Types.Base

Methods

lift :: Quote m => EntityIdDef -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => EntityIdDef -> Code m EntityIdDef

data EntityDef

An EntityDef represents the information that persistent knows about an Entity. It uses this information to generate the Haskell datatype, the SQL migrations, and other relevant conversions.

Instances

Read EntityDef

Defined in Database.Persist.Types.Base

Methods

readsPrec :: Int -> ReadS EntityDef

readList :: ReadS [EntityDef]

readPrec :: ReadPrec EntityDef

readListPrec :: ReadPrec [EntityDef]

Show EntityDef

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> EntityDef -> ShowS

show :: EntityDef -> String

showList :: [EntityDef] -> ShowS

Eq EntityDef

Defined in Database.Persist.Types.Base

Methods

(==) :: EntityDef -> EntityDef -> Bool

(/=) :: EntityDef -> EntityDef -> Bool

Ord EntityDef

Defined in Database.Persist.Types.Base

Methods

compare :: EntityDef -> EntityDef -> Ordering

(<) :: EntityDef -> EntityDef -> Bool

(<=) :: EntityDef -> EntityDef -> Bool

(>) :: EntityDef -> EntityDef -> Bool

(>=) :: EntityDef -> EntityDef -> Bool

max :: EntityDef -> EntityDef -> EntityDef

min :: EntityDef -> EntityDef -> EntityDef

Lift EntityDef

Defined in Database.Persist.Types.Base

Methods

lift :: Quote m => EntityDef -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => EntityDef -> Code m EntityDef

data WhyNullable

The reason why a field is nullable is very important. A field that is nullable because of a Maybe tag will have its type changed from A to Maybe A. OTOH, a field that is nullable because of a nullable tag will remain with the same type.

Constructors

ByMaybeAttr

ByNullableAttr

Instances

Show WhyNullable

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> WhyNullable -> ShowS

show :: WhyNullable -> String

showList :: [WhyNullable] -> ShowS

Eq WhyNullable

Defined in Database.Persist.Types.Base

Methods

(==) :: WhyNullable -> WhyNullable -> Bool

(/=) :: WhyNullable -> WhyNullable -> Bool

data IsNullable

Constructors

Nullable !WhyNullable

NotNullable

Instances

Show IsNullable

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> IsNullable -> ShowS

show :: IsNullable -> String

showList :: [IsNullable] -> ShowS

Eq IsNullable

Defined in Database.Persist.Types.Base

Methods

(==) :: IsNullable -> IsNullable -> Bool

(/=) :: IsNullable -> IsNullable -> Bool

data Checkmark

A Checkmark should be used as a field type whenever a uniqueness constraint should guarantee that a certain kind of record may appear at most once, but other kinds of records may appear any number of times.

NOTE: You need to mark any Checkmark fields as nullable (see the following example).

For example, suppose there's a Location entity that represents where a user has lived:

Location
    user    UserId
    name    Text
    current Checkmark nullable

    UniqueLocation user current

The UniqueLocation constraint allows any number of Inactive Locations to be current. However, there may be at most one current Location per user (i.e., either zero or one per user).

This data type works because of the way that SQL treats NULLable fields within uniqueness constraints. The SQL standard says that NULL values should be considered different, so we represent Inactive as SQL NULL, thus allowing any number of Inactive records. On the other hand, we represent Active as TRUE, so the uniqueness constraint will disallow more than one Active record.

Note: There may be DBMSs that do not respect the SQL standard's treatment of NULL values on uniqueness constraints, please check if this data type works before relying on it.

The SQL BOOLEAN type is used because it's the smallest data type available. Note that we never use FALSE, just TRUE and NULL. Provides the same behavior Maybe () would if () was a valid PersistField.

Constructors

Active

When used on a uniqueness constraint, there may be at most one Active record.

Inactive

When used on a uniqueness constraint, there may be any number of Inactive records.

Instances

Bounded Checkmark

Defined in Database.Persist.Types.Base

Methods

minBound :: Checkmark

maxBound :: Checkmark

Enum Checkmark

Defined in Database.Persist.Types.Base

Methods

succ :: Checkmark -> Checkmark

pred :: Checkmark -> Checkmark

toEnum :: Int -> Checkmark

fromEnum :: Checkmark -> Int

enumFrom :: Checkmark -> [Checkmark]

enumFromThen :: Checkmark -> Checkmark -> [Checkmark]

enumFromTo :: Checkmark -> Checkmark -> [Checkmark]

enumFromThenTo :: Checkmark -> Checkmark -> Checkmark -> [Checkmark]

Read Checkmark

Defined in Database.Persist.Types.Base

Methods

readsPrec :: Int -> ReadS Checkmark

readList :: ReadS [Checkmark]

readPrec :: ReadPrec Checkmark

readListPrec :: ReadPrec [Checkmark]

Show Checkmark

Defined in Database.Persist.Types.Base

Methods

showsPrec :: Int -> Checkmark -> ShowS

show :: Checkmark -> String

showList :: [Checkmark] -> ShowS

Eq Checkmark

Defined in Database.Persist.Types.Base

Methods

(==) :: Checkmark -> Checkmark -> Bool

(/=) :: Checkmark -> Checkmark -> Bool

Ord Checkmark

Defined in Database.Persist.Types.Base

Methods

compare :: Checkmark -> Checkmark -> Ordering

(<) :: Checkmark -> Checkmark -> Bool

(<=) :: Checkmark -> Checkmark -> Bool

(>) :: Checkmark -> Checkmark -> Bool

(>=) :: Checkmark -> Checkmark -> Bool

max :: Checkmark -> Checkmark -> Checkmark

min :: Checkmark -> Checkmark -> Checkmark

FromHttpApiData Checkmark

Defined in Database.Persist.Types.Base

Methods

parseUrlPiece :: Text -> Either Text Checkmark

parseHeader :: ByteString -> Either Text Checkmark

parseQueryParam :: Text -> Either Text Checkmark

ToHttpApiData Checkmark

Defined in Database.Persist.Types.Base

Methods

toUrlPiece :: Checkmark -> Text

toEncodedUrlPiece :: Checkmark -> Builder

toHeader :: Checkmark -> ByteString

toQueryParam :: Checkmark -> Text

toEncodedQueryParam :: Checkmark -> Builder

PathPiece Checkmark

Defined in Database.Persist.Types.Base

Methods

fromPathPiece :: Text -> Maybe Checkmark

toPathPiece :: Checkmark -> Text

PersistField Checkmark

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Checkmark -> PersistValue

fromPersistValue :: PersistValue -> Either Text Checkmark

PersistFieldSql Checkmark

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Checkmark -> SqlType

data Statement

A Statement is a representation of a database query that has been prepared and stored on the server side.

Constructors

Statement

Fields

• stmtFinalize :: IO ()
• stmtReset :: IO ()
• stmtExecute :: [PersistValue] -> IO Int64
• stmtQuery :: forall (m :: Type -> Type). MonadIO m => [PersistValue] -> Acquire (ConduitM () [PersistValue] m ())

data InsertSqlResult

Constructors

ISRSingle Text

ISRInsertGet Text Text

ISRManyKeys Text [PersistValue]

type LogFunc = Loc -> LogSource -> LogLevel -> LogStr -> IO ()

newtype OverflowNatural

Prior to persistent-2.11.0, we provided an instance of PersistField for the Natural type. This was in error, because Natural represents an infinite value, and databases don't have reasonable types for this.

The instance for Natural used the Int64 underlying type, which will cause underflow and overflow errors. This type has the exact same code in the instances, and will work seamlessly.

A more appropriate type for this is the Word series of types from Data.Word. These have a bounded size, are guaranteed to be non-negative, and are quite efficient for the database to store.

Since: persistent-2.11.0

Constructors

OverflowNatural

Fields

• unOverflowNatural :: Natural

Instances

Num OverflowNatural

Defined in Database.Persist.Class.PersistField

Methods

(+) :: OverflowNatural -> OverflowNatural -> OverflowNatural

(-) :: OverflowNatural -> OverflowNatural -> OverflowNatural

(*) :: OverflowNatural -> OverflowNatural -> OverflowNatural

negate :: OverflowNatural -> OverflowNatural

abs :: OverflowNatural -> OverflowNatural

signum :: OverflowNatural -> OverflowNatural

fromInteger :: Integer -> OverflowNatural

Show OverflowNatural

Defined in Database.Persist.Class.PersistField

Methods

showsPrec :: Int -> OverflowNatural -> ShowS

show :: OverflowNatural -> String

showList :: [OverflowNatural] -> ShowS

Eq OverflowNatural

Defined in Database.Persist.Class.PersistField

Methods

(==) :: OverflowNatural -> OverflowNatural -> Bool

(/=) :: OverflowNatural -> OverflowNatural -> Bool

Ord OverflowNatural

Defined in Database.Persist.Class.PersistField

Methods

compare :: OverflowNatural -> OverflowNatural -> Ordering

(<) :: OverflowNatural -> OverflowNatural -> Bool

(<=) :: OverflowNatural -> OverflowNatural -> Bool

(>) :: OverflowNatural -> OverflowNatural -> Bool

(>=) :: OverflowNatural -> OverflowNatural -> Bool

max :: OverflowNatural -> OverflowNatural -> OverflowNatural

min :: OverflowNatural -> OverflowNatural -> OverflowNatural

PersistField OverflowNatural

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: OverflowNatural -> PersistValue

fromPersistValue :: PersistValue -> Either Text OverflowNatural

PersistFieldSql OverflowNatural

This type uses the SqlInt64 version, which will exhibit overflow and underflow behavior. Additionally, it permits negative values in the database, which isn't ideal.

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy OverflowNatural -> SqlType

class PersistField a where

This class teaches Persistent how to take a custom type and marshal it to and from a PersistValue, allowing it to be stored in a database.

Examples

Simple Newtype

You can use newtype to add more type safety/readability to a basis type like ByteString. In these cases, just derive PersistField and PersistFieldSql:

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

newtype HashedPassword = HashedPassword ByteString
  deriving (Eq, Show, PersistField, PersistFieldSql)

Smart Constructor Newtype

In this example, we create a PersistField instance for a newtype following the "Smart Constructor" pattern.

{-# LANGUAGE GeneralizedNewtypeDeriving #-}
import qualified Data.Text as T
import qualified Data.Char as C

-- | An American Social Security Number
newtype SSN = SSN ErrorMessage
 deriving (Eq, Show, PersistFieldSql)

mkSSN :: ErrorMessage -> Either ErrorMessage SSN
mkSSN t = if (T.length t == 9) && (T.all C.isDigit t)
 then Right $ SSN t
 else Left $ "Invalid SSN: " <> t

instance PersistField SSN where
  toPersistValue (SSN t) = PersistText t
  fromPersistValue (PersistText t) = mkSSN t
  -- Handle cases where the database does not give us PersistText
  fromPersistValue x = Left $ "File.hs: When trying to deserialize an SSN: expected PersistText, received: " <> T.pack (show x)

Tips:

• This file contain dozens of PersistField instances you can look at for examples.
• Typically custom PersistField instances will only accept a single PersistValue constructor in fromPersistValue.
• Internal PersistField instances accept a wide variety of PersistValues to accomodate e.g. storing booleans as integers, booleans or strings.
• If you're making a custom instance and using a SQL database, you'll also need PersistFieldSql to specify the type of the database column.

Methods

toPersistValue :: a -> PersistValue

fromPersistValue :: PersistValue -> Either Text a

Instances

PersistField Int16

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Int16 -> PersistValue

fromPersistValue :: PersistValue -> Either Text Int16

PersistField Int32

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Int32 -> PersistValue

fromPersistValue :: PersistValue -> Either Text Int32

PersistField Int64

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Int64 -> PersistValue

fromPersistValue :: PersistValue -> Either Text Int64

PersistField Int8

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Int8 -> PersistValue

fromPersistValue :: PersistValue -> Either Text Int8

PersistField Rational

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Rational -> PersistValue

fromPersistValue :: PersistValue -> Either Text Rational

PersistField Word16

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Word16 -> PersistValue

fromPersistValue :: PersistValue -> Either Text Word16

PersistField Word32

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Word32 -> PersistValue

fromPersistValue :: PersistValue -> Either Text Word32

PersistField Word64

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Word64 -> PersistValue

fromPersistValue :: PersistValue -> Either Text Word64

PersistField Word8

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Word8 -> PersistValue

fromPersistValue :: PersistValue -> Either Text Word8

PersistField Html

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Html -> PersistValue

fromPersistValue :: PersistValue -> Either Text Html

PersistField ByteString

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: ByteString -> PersistValue

fromPersistValue :: PersistValue -> Either Text ByteString

PersistField OverflowNatural

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: OverflowNatural -> PersistValue

fromPersistValue :: PersistValue -> Either Text OverflowNatural

PersistField PersistValue

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: PersistValue -> PersistValue

fromPersistValue :: PersistValue -> Either Text PersistValue

PersistField Checkmark

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Checkmark -> PersistValue

fromPersistValue :: PersistValue -> Either Text Checkmark

PersistField Text

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Text -> PersistValue

fromPersistValue :: PersistValue -> Either Text Text

PersistField Text

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Text -> PersistValue

fromPersistValue :: PersistValue -> Either Text0 Text

PersistField Day

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Day -> PersistValue

fromPersistValue :: PersistValue -> Either Text Day

PersistField UTCTime

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: UTCTime -> PersistValue

fromPersistValue :: PersistValue -> Either Text UTCTime

PersistField TimeOfDay

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: TimeOfDay -> PersistValue

fromPersistValue :: PersistValue -> Either Text TimeOfDay

(TypeError ((((('Text "The instance of PersistField for the Natural type was removed." ':$$: 'Text "Please see the documentation for OverflowNatural if you want to ") ':$$: 'Text "continue using the old behavior or want to see documentation on ") ':$$: 'Text "why the instance was removed.") ':$$: 'Text "") ':$$: 'Text "This error instance will be removed in a future release.") :: Constraint) => PersistField Natural

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Natural -> PersistValue

fromPersistValue :: PersistValue -> Either Text Natural

PersistField Bool

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Bool -> PersistValue

fromPersistValue :: PersistValue -> Either Text Bool

PersistField Double

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Double -> PersistValue

fromPersistValue :: PersistValue -> Either Text Double

PersistField Int

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Int -> PersistValue

fromPersistValue :: PersistValue -> Either Text Int

PersistField Word

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Word -> PersistValue

fromPersistValue :: PersistValue -> Either Text Word

PersistField v => PersistField (IntMap v)

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: IntMap v -> PersistValue

fromPersistValue :: PersistValue -> Either Text (IntMap v)

(Ord a, PersistField a) => PersistField (Set a)

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Set a -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Set a)

(FromJSON a, ToJSON a) => PersistField (JSONB a)

Since: 3.1.0

Defined in Database.Esqueleto.PostgreSQL.JSON.Instances

Methods

toPersistValue :: JSONB a -> PersistValue

fromPersistValue :: PersistValue -> Either Text (JSONB a)

(PersistEntity record, PersistField record, PersistField (Key record)) => PersistField (Entity record)

Defined in Database.Persist.Class.PersistEntity

Methods

toPersistValue :: Entity record -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Entity record)

PersistField a => PersistField (Vector a)

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Vector a -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Vector a)

PersistField a => PersistField (Maybe a)

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Maybe a -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Maybe a)

PersistField [Char]

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: [Char] -> PersistValue

fromPersistValue :: PersistValue -> Either Text [Char]

PersistField a => PersistField [a]

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: [a] -> PersistValue

fromPersistValue :: PersistValue -> Either Text [a]

HasResolution a => PersistField (Fixed a)

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Fixed a -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Fixed a)

PersistField v => PersistField (Map Text v)

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Map Text v -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Map Text v)

(PersistField a, PersistField b) => PersistField (a, b)

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: (a, b) -> PersistValue

fromPersistValue :: PersistValue -> Either Text (a, b)

class SafeToInsert a

A type class which is used to witness that a type is safe to insert into the database without providing a primary key.

The TemplateHaskell function mkPersist will generate instances of this class for any entity that it works on. If the entity has a default primary key, then it provides a regular instance. If the entity has a Primary natural key, then this works fine. But if the entity has an Id column with no default=, then this does a TypeError and forces the user to use insertKey.

Since: persistent-2.14.0.0

Instances

(TypeError (EntityErrorMessage a) :: Constraint) => SafeToInsert (Entity a)

Defined in Database.Persist.Class.PersistEntity

(TypeError (FunctionErrorMessage a b) :: Constraint) => SafeToInsert (a -> b)

Defined in Database.Persist.Class.PersistEntity

class SymbolToField (sym :: Symbol) rec typ | sym rec -> typ where

This type class is used with the OverloadedLabels extension to provide a more convenient means of using the EntityField type. EntityField definitions are prefixed with the type name to avoid ambiguity, but this ambiguity can result in verbose code.

If you have a table User with a name Text field, then the corresponding EntityField is UserName. With this, we can write #name :: EntityField User Text.

What's more fun is that the type is more general: it's actually #name :: (SymbolToField "name" rec typ) => EntityField rec typ

Which means it is *polymorphic* over the actual record. This allows you to write code that can be generic over the tables, provided they have the right fields.

Since: persistent-2.11.0.0

Methods

symbolToField :: EntityField rec typ

data Entity record

Datatype that represents an entity, with both its Key and its Haskell record representation.

When using a SQL-based backend (such as SQLite or PostgreSQL), an Entity may take any number of columns depending on how many fields it has. In order to reconstruct your entity on the Haskell side, persistent needs all of your entity columns and in the right order. Note that you don't need to worry about this when using persistent's API since everything is handled correctly behind the scenes.

However, if you want to issue a raw SQL command that returns an Entity, then you have to be careful with the column order. While you could use SELECT Entity.* WHERE ... and that would work most of the time, there are times when the order of the columns on your database is different from the order that persistent expects (for example, if you add a new field in the middle of you entity definition and then use the migration code -- persistent will expect the column to be in the middle, but your DBMS will put it as the last column). So, instead of using a query like the one above, you may use rawSql (from the Database.Persist.Sql module) with its /entity selection placeholder/ (a double question mark ??). Using rawSql the query above must be written as SELECT ?? WHERE ... Then rawSql will replace ?? with the list of all columns that we need from your entity in the right order. If your query returns two entities (i.e. (Entity backend a, Entity backend b)), then you must you use SELECT ??, ?? WHERE ..., and so on.

Constructors

Entity

Fields

• entityKey :: Key record
• entityVal :: record

Instances

(PersistEntity rec, PersistField typ, SymbolToField sym rec typ) => HasField (sym :: Symbol) (SqlExpr (Entity rec)) (SqlExpr (Value typ))

This instance allows you to use record.field notation with GHC 9.2's OverloadedRecordDot extension.

Example:

-- persistent model:
BlogPost
    authorId     PersonId
    title        Text

-- query:
select $ do
    bp <- from $ table @BlogPost
    pure $ bp.title

This is exactly equivalent to the following:

blogPost :: SqlExpr (Entity BlogPost)

blogPost ^. BlogPostTitle
blogPost ^. #title
blogPost.title

There's another instance defined on SqlExpr (Entity (Maybe rec)), which allows you to project from a LEFT JOINed entity.

Since: 3.5.4.0

Defined in Database.Esqueleto.Internal.Internal

Methods

getField :: SqlExpr (Entity rec) -> SqlExpr (Value typ)

(PersistEntity rec, PersistField typ, SymbolToField sym rec typ) => HasField (sym :: Symbol) (SqlExpr (Maybe (Entity rec))) (SqlExpr (Value (Maybe typ)))

This instance allows you to use record.field notation with GC 9.2's OverloadedRecordDot extension.

Example:

-- persistent model:
Person
    name         Text

BlogPost
    title        Text
    authorId     PersonId

-- query:

select $ do
    (p :& bp) <- from $
        table Person
        leftJoin table BlogPost
        on do
            \(p :& bp) ->
                just p.id ==. bp.authorId
    pure (p.name, bp.title)

The following forms are all equivalent:

blogPost :: SqlExpr (Maybe (Entity BlogPost))

blogPost ?. BlogPostTitle
blogPost ?. #title
blogPost.title

Since: 3.5.4.0

Defined in Database.Esqueleto.Internal.Internal

Methods

getField :: SqlExpr (Maybe (Entity rec)) -> SqlExpr (Value (Maybe typ))

(Generic (Key record), Generic record) => Generic (Entity record)

Defined in Database.Persist.Class.PersistEntity

Associated Types

type Rep (Entity record) :: Type -> Type

Methods

from :: Entity record -> Rep (Entity record) x

to :: Rep (Entity record) x -> Entity record

(Read (Key record), Read record) => Read (Entity record)

Defined in Database.Persist.Class.PersistEntity

Methods

readsPrec :: Int -> ReadS (Entity record)

readList :: ReadS [Entity record]

readPrec :: ReadPrec (Entity record)

readListPrec :: ReadPrec [Entity record]

(Show (Key record), Show record) => Show (Entity record)

Defined in Database.Persist.Class.PersistEntity

Methods

showsPrec :: Int -> Entity record -> ShowS

show :: Entity record -> String

showList :: [Entity record] -> ShowS

ToAlias (SqlExpr (Entity a))

Defined in Database.Esqueleto.Experimental.ToAlias

Methods

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

ToAlias (SqlExpr (Maybe (Entity a)))

Defined in Database.Esqueleto.Experimental.ToAlias

Methods

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

ToAliasReference (SqlExpr (Entity a))

Defined in Database.Esqueleto.Experimental.ToAliasReference

Methods

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

ToAliasReference (SqlExpr (Maybe (Entity a)))

Defined in Database.Esqueleto.Experimental.ToAliasReference

Methods

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

ToMaybe (SqlExpr (Entity a))

Defined in Database.Esqueleto.Experimental.ToMaybe

Associated Types

type ToMaybeT (SqlExpr (Entity a))

Methods

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

FromPreprocess (SqlExpr (Entity val)) => From (SqlExpr (Entity val))

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (SqlExpr (Entity val))

FromPreprocess (SqlExpr (Maybe (Entity val))) => From (SqlExpr (Maybe (Entity val)))

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (SqlExpr (Maybe (Entity val)))

(PersistEntity val, BackendCompatible SqlBackend (PersistEntityBackend val)) => FromPreprocess (SqlExpr (Entity val))

Defined in Database.Esqueleto.Internal.Internal

Methods

fromPreprocess :: SqlQuery (PreprocessedFrom (SqlExpr (Entity val)))

(PersistEntity val, BackendCompatible SqlBackend (PersistEntityBackend val)) => FromPreprocess (SqlExpr (Maybe (Entity val)))

Defined in Database.Esqueleto.Internal.Internal

Methods

fromPreprocess :: SqlQuery (PreprocessedFrom (SqlExpr (Maybe (Entity val))))

PersistEntity val => LockableEntity (SqlExpr (Entity val))

Defined in Database.Esqueleto.Internal.Internal

Methods

flattenLockableEntity :: SqlExpr (Entity val) -> NonEmpty LockableSqlExpr

(Eq (Key record), Eq record) => Eq (Entity record)

Defined in Database.Persist.Class.PersistEntity

Methods

(==) :: Entity record -> Entity record -> Bool

(/=) :: Entity record -> Entity record -> Bool

(Ord (Key record), Ord record) => Ord (Entity record)

Defined in Database.Persist.Class.PersistEntity

Methods

compare :: Entity record -> Entity record -> Ordering

(<) :: Entity record -> Entity record -> Bool

(<=) :: Entity record -> Entity record -> Bool

(>) :: Entity record -> Entity record -> Bool

(>=) :: Entity record -> Entity record -> Bool

max :: Entity record -> Entity record -> Entity record

min :: Entity record -> Entity record -> Entity record

(TypeError (EntityErrorMessage a) :: Constraint) => SafeToInsert (Entity a)

Defined in Database.Persist.Class.PersistEntity

(PersistEntity record, PersistField record, PersistField (Key record)) => PersistField (Entity record)

Defined in Database.Persist.Class.PersistEntity

Methods

toPersistValue :: Entity record -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Entity record)

(PersistField record, PersistEntity record) => PersistFieldSql (Entity record)

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy (Entity record) -> SqlType

(PersistEntity record, PersistEntityBackend record ~ backend, IsPersistBackend backend) => RawSql (Entity record)

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> Entity record -> (Int, [Text])

rawSqlColCountReason :: Entity record -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (Entity record)

PersistEntity ent => ToFrom (Table ent) (SqlExpr (Entity ent))

Defined in Database.Esqueleto.Experimental.From

Methods

toFrom :: Table ent -> From (SqlExpr (Entity ent))

PersistEntity a => SqlSelect (SqlExpr (Entity a)) (Entity a)

You may return an Entity from a select query.

Defined in Database.Esqueleto.Internal.Internal

Methods

sqlSelectCols :: IdentInfo -> SqlExpr (Entity a) -> (Builder, [PersistValue])

sqlSelectColCount :: Proxy (SqlExpr (Entity a)) -> Int

sqlSelectProcessRow :: [PersistValue] -> Either Text (Entity a)

sqlInsertInto :: IdentInfo -> SqlExpr (Entity a) -> (Builder, [PersistValue])

PersistEntity a => SqlSelect (SqlExpr (Maybe (Entity a))) (Maybe (Entity a))

You may return a possibly-NULL Entity from a select query.

Defined in Database.Esqueleto.Internal.Internal

Methods

sqlSelectCols :: IdentInfo -> SqlExpr (Maybe (Entity a)) -> (Builder, [PersistValue])

sqlSelectColCount :: Proxy (SqlExpr (Maybe (Entity a))) -> Int

sqlSelectProcessRow :: [PersistValue] -> Either Text (Maybe (Entity a))

sqlInsertInto :: IdentInfo -> SqlExpr (Maybe (Entity a)) -> (Builder, [PersistValue])

type Rep (Entity record)

Defined in Database.Persist.Class.PersistEntity

type Rep (Entity record) = D1 ('MetaData "Entity" "Database.Persist.Class.PersistEntity" "persistent-2.14.6.1-xgENLTHBf06k1BlJ0bdD3" 'False) (C1 ('MetaCons "Entity" 'PrefixI 'True) (S1 ('MetaSel ('Just "entityKey") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Key record)) :*: S1 ('MetaSel ('Just "entityVal") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 record)))

type ToMaybeT (SqlExpr (Entity a))

Defined in Database.Esqueleto.Experimental.ToMaybe

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

data FilterValue typ where

Value to filter with. Highly dependant on the type of filter used.

Since: persistent-2.10.0

Constructors

FilterValue :: forall typ. typ -> FilterValue typ

FilterValues :: forall typ. [typ] -> FilterValue typ

UnsafeValue :: forall a typ. PersistField a => a -> FilterValue typ

type family PersistEntityBackend record

Persistent allows multiple different backends (databases).

data family EntityField record :: Type -> Type

An EntityField is parameterised by the Haskell record it belongs to and the additional type of that field.

As of persistent-2.11.0.0, it's possible to use the OverloadedLabels language extension to refer to EntityField values polymorphically. See the documentation on SymbolToField for more information.

Instances

SymbolToField sym rec typ => IsLabel sym (EntityField rec typ)

This instance delegates to SymbolToField to provide OverloadedLabels support to the EntityField type.

Since: persistent-2.11.0.0

Defined in Database.Persist.Class.PersistEntity

Methods

fromLabel :: EntityField rec typ

class (Show (BackendKey backend), Read (BackendKey backend), Eq (BackendKey backend), Ord (BackendKey backend), PersistStoreRead backend, PersistField (BackendKey backend), ToJSON (BackendKey backend), FromJSON (BackendKey backend)) => PersistStoreWrite backend where

Minimal complete definition

insert, insertKey, repsert, replace, delete, update

Methods

insert :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Key record)

Create a new record in the database, returning an automatically created key (in SQL an auto-increment id).

Example usage

Using schema-1 and dataset-1, let's insert a new user John.

insertJohn :: MonadIO m => ReaderT SqlBackend m (Key User)
insertJohn = insert $ User "John" 30

johnId <- insertJohn

The above query when applied on dataset-1, will produce this:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |John  |30   |
+-----+------+-----+

insert_ :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m ()

Same as insert, but doesn't return a Key.

Example usage

with schema-1 and dataset-1,

insertJohn :: MonadIO m => ReaderT SqlBackend m (Key User)
insertJohn = insert_ $ User "John" 30

The above query when applied on dataset-1, will produce this:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |John  |30   |
+-----+------+-----+

insertMany :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => [record] -> ReaderT backend m [Key record]

Create multiple records in the database and return their Keys.

If you don't need the inserted Keys, use insertMany_.

The MongoDB and PostgreSQL backends insert all records and retrieve their keys in one database query.

The SQLite and MySQL backends use the slow, default implementation of mapM insert.

Example usage

with schema-1 and dataset-1,

insertUsers :: MonadIO m => ReaderT SqlBackend m [Key User]
insertUsers = insertMany [User "John" 30, User "Nick" 32, User "Jane" 20]

userIds <- insertUsers

The above query when applied on dataset-1, will produce this:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |John  |30   |
+-----+------+-----+
|4    |Nick  |32   |
+-----+------+-----+
|5    |Jane  |20   |
+-----+------+-----+

insertMany_ :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => [record] -> ReaderT backend m ()

Same as insertMany, but doesn't return any Keys.

The MongoDB, PostgreSQL, SQLite and MySQL backends insert all records in one database query.

Example usage

With schema-1 and dataset-1,

insertUsers_ :: MonadIO m => ReaderT SqlBackend m ()
insertUsers_ = insertMany_ [User "John" 30, User "Nick" 32, User "Jane" 20]

The above query when applied on dataset-1, will produce this:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |John  |30   |
+-----+------+-----+
|4    |Nick  |32   |
+-----+------+-----+
|5    |Jane  |20   |
+-----+------+-----+

insertEntityMany :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => [Entity record] -> ReaderT backend m ()

Same as insertMany_, but takes an Entity instead of just a record.

Useful when migrating data from one entity to another and want to preserve ids.

The MongoDB, PostgreSQL, SQLite and MySQL backends insert all records in one database query.

Example usage

With schema-1 and dataset-1,

insertUserEntityMany :: MonadIO m => ReaderT SqlBackend m ()
insertUserEntityMany = insertEntityMany [SnakeEntity, EvaEntity]

The above query when applied on dataset-1, will produce this:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |Snake |38   |
+-----+------+-----+
|4    |Eva   |38   |
+-----+------+-----+

insertKey :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Key record -> record -> ReaderT backend m ()

Create a new record in the database using the given key.

Example usage

With schema-1 and dataset-1,

insertAliceKey :: MonadIO m => Key User -> ReaderT SqlBackend m ()
insertAliceKey key = insertKey key $ User "Alice" 20

insertAliceKey $ UserKey {unUserKey = SqlBackendKey {unSqlBackendKey = 3}}

The above query when applied on dataset-1, will produce this:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |Alice |20   |
+-----+------+-----+

repsert :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Key record -> record -> ReaderT backend m ()

Put the record in the database with the given key. Unlike replace, if a record with the given key does not exist then a new record will be inserted.

Example usage

We try to explain upsertBy using schema-1 and dataset-1.

First, we insert Philip to dataset-1.

insertPhilip :: MonadIO m => ReaderT SqlBackend m (Key User)
insertPhilip = insert $ User "Philip" 42

philipId <- insertPhilip

This query will produce:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |Philip|42   |
+-----+------+-----+

repsertHaskell :: MonadIO m => Key record -> ReaderT SqlBackend m ()
repsertHaskell id = repsert id $ User "Haskell" 81

repsertHaskell philipId

This query will replace Philip's record with Haskell's one:

+-----+-----------------+--------+
|id   |name             |age     |
+-----+-----------------+--------+
|1    |SPJ              |40      |
+-----+-----------------+--------+
|2    |Simon            |41      |
+-----+-----------------+--------+
|3    |Philip -> Haskell|42 -> 81|
+-----+-----------------+--------+

repsert inserts the given record if the key doesn't exist.

repsertXToUnknown :: MonadIO m => ReaderT SqlBackend m ()
repsertXToUnknown = repsert unknownId $ User "X" 999

For example, applying the above query to dataset-1 will produce this:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |X     |999  |
+-----+------+-----+

repsertMany :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => [(Key record, record)] -> ReaderT backend m ()

Put many entities into the database.

Batch version of repsert for SQL backends.

Useful when migrating data from one entity to another and want to preserve ids.

Example usage

With schema-1 and dataset-1,

repsertManyUsers :: MonadIO m =>ReaderT SqlBackend m ()
repsertManyusers = repsertMany [(simonId, User "Philip" 20), (unknownId999, User "Mr. X" 999)]

The above query when applied on dataset-1, will produce this:

+-----+----------------+---------+
|id   |name            |age      |
+-----+----------------+---------+
|1    |SPJ             |40       |
+-----+----------------+---------+
|2    |Simon -> Philip |41 -> 20 |
+-----+----------------+---------+
|999  |Mr. X           |999      |
+-----+----------------+---------+

Since: persistent-2.8.1

replace :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Key record -> record -> ReaderT backend m ()

Replace the record in the database with the given key. Note that the result is undefined if such record does not exist, so you must use insertKey or repsert in these cases.

Example usage

With schema-1 schama-1 and dataset-1,

replaceSpj :: MonadIO m => User -> ReaderT SqlBackend m ()
replaceSpj record = replace spjId record

The above query when applied on dataset-1, will produce this:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |Mike  |45   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+

updateGet :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Key record -> [Update record] -> ReaderT backend m record

Update individual fields on a specific record, and retrieve the updated value from the database.

Note that this function will throw an exception if the given key is not found in the database.

Example usage

With schema-1 and dataset-1,

updateGetSpj :: MonadIO m => [Update User] -> ReaderT SqlBackend m User
updateGetSpj updates = updateGet spjId updates

spj <- updateGetSpj [UserAge +=. 100]

The above query when applied on dataset-1, will produce this:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |140  |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+

class (Show (BackendKey backend), Read (BackendKey backend), Eq (BackendKey backend), Ord (BackendKey backend), PersistCore backend, PersistField (BackendKey backend), ToJSON (BackendKey backend), FromJSON (BackendKey backend)) => PersistStoreRead backend where

Minimal complete definition

get

Methods

get :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Key record -> ReaderT backend m (Maybe record)

Get a record by identifier, if available.

Example usage

With schema-1 and dataset-1,

getSpj :: MonadIO m => ReaderT SqlBackend m (Maybe User)
getSpj = get spjId

mspj <- getSpj

The above query when applied on dataset-1, will get this:

+------+-----+
| name | age |
+------+-----+
| SPJ  |  40 |
+------+-----+

getMany :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => [Key record] -> ReaderT backend m (Map (Key record) record)

Get many records by their respective identifiers, if available.

Example usage

With schema-1 and dataset-1:

getUsers :: MonadIO m => ReaderT SqlBackend m (Map (Key User) User)
getUsers = getMany allkeys

musers <- getUsers

The above query when applied on dataset-1, will get these records:

+----+-------+-----+
| id | name  | age |
+----+-------+-----+
|  1 | SPJ   |  40 |
+----+-------+-----+
|  2 | Simon |  41 |
+----+-------+-----+

Since: persistent-2.8.1

class PersistCore backend

Associated Types

data BackendKey backend

data family BackendKey backend

Instances

newtype BackendKey SqlReadBackend

Defined in Database.Persist.Sql.Orphan.PersistStore

newtype BackendKey SqlReadBackend = SqlReadBackendKey {

• unSqlReadBackendKey :: Int64

}

newtype BackendKey SqlWriteBackend

Defined in Database.Persist.Sql.Orphan.PersistStore

newtype BackendKey SqlWriteBackend = SqlWriteBackendKey {

• unSqlWriteBackendKey :: Int64

}

newtype BackendKey SqlBackend

Defined in Database.Persist.Sql.Orphan.PersistStore

newtype BackendKey SqlBackend = SqlBackendKey {

• unSqlBackendKey :: Int64

}

type Rep (BackendKey SqlReadBackend)

Defined in Database.Persist.Sql.Orphan.PersistStore

type Rep (BackendKey SqlReadBackend) = D1 ('MetaData "BackendKey" "Database.Persist.Sql.Orphan.PersistStore" "persistent-2.14.6.1-xgENLTHBf06k1BlJ0bdD3" 'True) (C1 ('MetaCons "SqlReadBackendKey" 'PrefixI 'True) (S1 ('MetaSel ('Just "unSqlReadBackendKey") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int64)))

type Rep (BackendKey SqlWriteBackend)

Defined in Database.Persist.Sql.Orphan.PersistStore

type Rep (BackendKey SqlWriteBackend) = D1 ('MetaData "BackendKey" "Database.Persist.Sql.Orphan.PersistStore" "persistent-2.14.6.1-xgENLTHBf06k1BlJ0bdD3" 'True) (C1 ('MetaCons "SqlWriteBackendKey" 'PrefixI 'True) (S1 ('MetaSel ('Just "unSqlWriteBackendKey") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int64)))

type Rep (BackendKey SqlBackend)

Defined in Database.Persist.Sql.Orphan.PersistStore

type Rep (BackendKey SqlBackend) = D1 ('MetaData "BackendKey" "Database.Persist.Sql.Orphan.PersistStore" "persistent-2.14.6.1-xgENLTHBf06k1BlJ0bdD3" 'True) (C1 ('MetaCons "SqlBackendKey" 'PrefixI 'True) (S1 ('MetaSel ('Just "unSqlBackendKey") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int64)))

class (PersistEntity record, PersistEntityBackend record ~ backend, PersistCore backend) => ToBackendKey backend record where

ToBackendKey converts a PersistEntity Key into a BackendKey This can be used by each backend to convert between a Key and a plain Haskell type. For Sql, that is done with toSqlKey and fromSqlKey.

By default, a PersistEntity uses the default BackendKey for its Key and is an instance of ToBackendKey

A Key that instead uses a custom type will not be an instance of ToBackendKey.

Methods

toBackendKey :: Key record -> BackendKey backend

fromBackendKey :: BackendKey backend -> Key record

type PersistRecordBackend record backend = (PersistEntity record, PersistEntityBackend record ~ BaseBackend backend)

A convenient alias for common type signatures

class BackendCompatible sup sub where

This class witnesses that two backend are compatible, and that you can convert from the sub backend into the sup backend. This is similar to the HasPersistBackend and IsPersistBackend classes, but where you don't want to fix the type associated with the PersistEntityBackend of a record.

Generally speaking, where you might have:

foo ::
  ( PersistEntity record
  , PersistEntityBackend record ~ BaseBackend backend
  , IsSqlBackend backend
  )

this can be replaced with:

foo ::
  ( PersistEntity record,
  , PersistEntityBackend record ~ backend
  , BackendCompatible SqlBackend backend
  )

This works for SqlReadBackend because of the instance BackendCompatible SqlBackend SqlReadBackend, without needing to go through the BaseBackend type family.

Likewise, functions that are currently hardcoded to use SqlBackend can be generalized:

-- before:
asdf :: ReaderT SqlBackend m ()
asdf = pure ()

-- after:
asdf' :: BackendCompatible SqlBackend backend => ReaderT backend m ()
asdf' = withCompatibleBackend asdf

Since: persistent-2.7.1

Methods

projectBackend :: sub -> sup

class HasPersistBackend backend => IsPersistBackend backend

Class which witnesses that backend is essentially the same as BaseBackend backend. That is, they're isomorphic and backend is just some wrapper over BaseBackend backend.

Minimal complete definition

mkPersistBackend

Instances

IsPersistBackend SqlReadBackend

Defined in Database.Persist.Sql.Types.Internal

Methods

mkPersistBackend :: BaseBackend SqlReadBackend -> SqlReadBackend

IsPersistBackend SqlWriteBackend

Defined in Database.Persist.Sql.Types.Internal

Methods

mkPersistBackend :: BaseBackend SqlWriteBackend -> SqlWriteBackend

IsPersistBackend SqlBackend

Defined in Database.Persist.SqlBackend.Internal

Methods

mkPersistBackend :: BaseBackend SqlBackend -> SqlBackend

class HasPersistBackend backend where

Class which allows the plucking of a BaseBackend backend from some larger type. For example, instance HasPersistBackend (SqlReadBackend, Int) where type BaseBackend (SqlReadBackend, Int) = SqlBackend persistBackend = unSqlReadBackend . fst

Associated Types

type BaseBackend backend

Methods

persistBackend :: backend -> BaseBackend backend

Instances

HasPersistBackend SqlReadBackend

Defined in Database.Persist.Sql.Types.Internal

Associated Types

type BaseBackend SqlReadBackend

Methods

persistBackend :: SqlReadBackend -> BaseBackend SqlReadBackend

HasPersistBackend SqlWriteBackend

Defined in Database.Persist.Sql.Types.Internal

Associated Types

type BaseBackend SqlWriteBackend

Methods

persistBackend :: SqlWriteBackend -> BaseBackend SqlWriteBackend

HasPersistBackend SqlBackend

Defined in Database.Persist.SqlBackend.Internal

Associated Types

type BaseBackend SqlBackend

Methods

persistBackend :: SqlBackend -> BaseBackend SqlBackend

type family BaseBackend backend

Instances

type BaseBackend SqlReadBackend

Defined in Database.Persist.Sql.Types.Internal

type BaseBackend SqlReadBackend = SqlBackend

type BaseBackend SqlWriteBackend

Defined in Database.Persist.Sql.Types.Internal

type BaseBackend SqlWriteBackend = SqlBackend

type BaseBackend SqlBackend

Defined in Database.Persist.SqlBackend.Internal

type BaseBackend SqlBackend = SqlBackend

data SqlBackend

A SqlBackend represents a handle or connection to a database. It contains functions and values that allow databases to have more optimized implementations, as well as references that benefit performance and sharing.

Instead of using the SqlBackend constructor directly, use the mkSqlBackend function.

A SqlBackend is *not* thread-safe. You should not assume that a SqlBackend can be shared among threads and run concurrent queries. This *will* result in problems. Instead, you should create a Pool SqlBackend, known as a ConnectionPool, and pass that around in multi-threaded applications.

To run actions in the persistent library, you should use the runSqlConn function. If you're using a multithreaded application, use the runSqlPool function.

Instances

HasPersistBackend SqlBackend

Defined in Database.Persist.SqlBackend.Internal

Associated Types

type BaseBackend SqlBackend

Methods

persistBackend :: SqlBackend -> BaseBackend SqlBackend

IsPersistBackend SqlBackend

Defined in Database.Persist.SqlBackend.Internal

Methods

mkPersistBackend :: BaseBackend SqlBackend -> SqlBackend

newtype BackendKey SqlBackend

Defined in Database.Persist.Sql.Orphan.PersistStore

newtype BackendKey SqlBackend = SqlBackendKey {

• unSqlBackendKey :: Int64

}

type BaseBackend SqlBackend

Defined in Database.Persist.SqlBackend.Internal

type BaseBackend SqlBackend = SqlBackend

type Rep (BackendKey SqlBackend)

Defined in Database.Persist.Sql.Orphan.PersistStore

type Rep (BackendKey SqlBackend) = D1 ('MetaData "BackendKey" "Database.Persist.Sql.Orphan.PersistStore" "persistent-2.14.6.1-xgENLTHBf06k1BlJ0bdD3" 'True) (C1 ('MetaCons "SqlBackendKey" 'PrefixI 'True) (S1 ('MetaSel ('Just "unSqlBackendKey") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int64)))

class PersistEntity record => AtLeastOneUniqueKey record where

This class is used to ensure that functions requring at least one unique key are not called with records that have 0 unique keys. The quasiquoter automatically writes working instances for appropriate entities, and generates TypeError instances for records that have 0 unique keys.

Since: persistent-2.10.0

Methods

requireUniquesP :: record -> NonEmpty (Unique record)

type MultipleUniqueKeysError ty = ((('Text "The entity " ':<>: 'ShowType ty) ':<>: 'Text " has multiple unique keys.") ':$$: ('Text "The function you are trying to call requires only a single " ':<>: 'Text "unique key.")) ':$$: (('Text "There is probably a variant of the function with 'By' " ':<>: 'Text "appended that will allow you to select a unique key ") ':<>: 'Text "for the operation.")

This is an error message. It is used when an entity has multiple unique keys, and the function expects a single unique key.

Since: persistent-2.10.0

type NoUniqueKeysError ty = (('Text "The entity " ':<>: 'ShowType ty) ':<>: 'Text " does not have any unique keys.") ':$$: ('Text "The function you are trying to call requires a unique key " ':<>: 'Text "to be defined on the entity.")

This is an error message. It is used when writing instances of OnlyOneUniqueKey for an entity that has no unique keys.

Since: persistent-2.10.0

class PersistEntity record => OnlyOneUniqueKey record where

This class is used to ensure that upsert is only called on records that have a single Unique key. The quasiquoter automatically generates working instances for appropriate records, and generates TypeError instances for records that have 0 or multiple unique keys.

Since: persistent-2.10.0

Methods

onlyUniqueP :: record -> Unique record

class (PersistUniqueRead backend, PersistStoreWrite backend) => PersistUniqueWrite backend where

Some functions in this module (insertUnique, insertBy, and replaceUnique) first query the unique indexes to check for conflicts. You could instead optimistically attempt to perform the operation (e.g. replace instead of replaceUnique). However,

• there is some fragility to trying to catch the correct exception and determing the column of failure;
• an exception will automatically abort the current SQL transaction.

Minimal complete definition

deleteBy

Methods

deleteBy :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m ()

Delete a specific record by unique key. Does nothing if no record matches.

Example usage

With schema-1 and dataset-1,

deleteBySpjName :: MonadIO m => ReaderT SqlBackend m ()
deleteBySpjName = deleteBy UniqueUserName "SPJ"

The above query when applied on dataset-1, will produce this:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+

insertUnique :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Maybe (Key record))

Like insert, but returns Nothing when the record couldn't be inserted because of a uniqueness constraint.

Example usage

With schema-1 and dataset-1, we try to insert the following two records:

linusId <- insertUnique $ User "Linus" 48
spjId   <- insertUnique $ User "SPJ" 90

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |Linus |48   |
+-----+------+-----+

Linus's record was inserted to dataset-1, while SPJ wasn't because SPJ already exists in dataset-1.

insertUnique_ :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Maybe ())

Same as insertUnique but doesn't return a Key.

Example usage

With schema-1 and dataset-1, we try to insert the following two records:

linusId <- insertUnique_ $ User "Linus" 48
spjId   <- insertUnique_ $ User "SPJ" 90

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |Linus |48   |
+-----+------+-----+

Linus's record was inserted to dataset-1, while SPJ wasn't because SPJ already exists in dataset-1.

Since: persistent-2.14.5.0

upsert

Arguments

:: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, OnlyOneUniqueKey record, SafeToInsert record)

=> record

new record to insert

-> [Update record]

updates to perform if the record already exists

-> ReaderT backend m (Entity record)

the record in the database after the operation

Update based on a uniqueness constraint or insert:

• insert the new record if it does not exist;
• If the record exists (matched via it's uniqueness constraint), then update the existing record with the parameters which is passed on as list to the function.

Example usage

First, we try to explain upsert using schema-1 and dataset-1.

upsertSpj :: MonadIO m => [Update User] -> ReaderT SqlBackend m (Maybe (Entity User))
upsertSpj updates = upsert (User "SPJ" 999) updates

mSpjEnt <- upsertSpj [UserAge +=. 15]

The above query when applied on dataset-1, will produce this:

+-----+-----+--------+
|id   |name |age     |
+-----+-----+--------+
|1    |SPJ  |40 -> 55|
+-----+-----+--------+
|2    |Simon|41      |
+-----+-----+--------+

upsertX :: MonadIO m => [Update User] -> ReaderT SqlBackend m (Maybe (Entity User))
upsertX updates = upsert (User "X" 999) updates

mXEnt <- upsertX [UserAge +=. 15]

The above query when applied on dataset-1, will produce this:

+-----+-----+--------+
|id   |name |age     |
+-----+-----+--------+
|1    |SPJ  |40      |
+-----+-----+--------+
|2    |Simon|41      |
+-----+-----+--------+
|3    |X    |999     |
+-----+-----+--------+

Next, what if the schema has two uniqueness constraints? Let's check it out using schema-2:

mSpjEnt <- upsertSpj [UserAge +=. 15]

This fails with a compile-time type error alerting us to the fact that this record has multiple unique keys, and suggests that we look for upsertBy to select the unique key we want.

upsertBy

Arguments

:: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record)

=> Unique record

uniqueness constraint to find by

-> record

new record to insert

-> [Update record]

updates to perform if the record already exists

-> ReaderT backend m (Entity record)

the record in the database after the operation

Update based on a given uniqueness constraint or insert:

• insert the new record if it does not exist;
• update the existing record that matches the given uniqueness constraint.

Example usage

We try to explain upsertBy using schema-2 and dataset-1.

upsertBySpjName :: MonadIO m => User -> [Update User] -> ReaderT SqlBackend m (Entity User)
upsertBySpjName record updates = upsertBy (UniqueUserName "SPJ") record updates

mSpjEnt <- upsertBySpjName (Person "X" 999) [PersonAge += .15]

The above query will alter dataset-1 to:

+-----+-----+--------+
|id   |name |age     |
+-----+-----+--------+
|1    |SPJ  |40 -> 55|
+-----+-----+--------+
|2    |Simon|41      |
+-----+-----+--------+

upsertBySimonAge :: MonadIO m => User -> [Update User] -> ReaderT SqlBackend m (Entity User)
upsertBySimonAge record updates = upsertBy (UniqueUserName "SPJ") record updates

mPhilipEnt <- upsertBySimonAge (User "X" 999) [UserName =. "Philip"]

The above query will alter dataset-1 to:

+----+-----------------+-----+
| id |      name       | age |
+----+-----------------+-----+
|  1 | SPJ             |  40 |
+----+-----------------+-----+
|  2 | Simon -> Philip |  41 |
+----+-----------------+-----+

upsertByUnknownName :: MonadIO m => User -> [Update User] -> ReaderT SqlBackend m (Entity User)
upsertByUnknownName record updates = upsertBy (UniqueUserName "Unknown") record updates

mXEnt <- upsertByUnknownName (User "X" 999) [UserAge +=. 15]

This query will alter dataset-1 to:

+-----+-----+-----+
|id   |name |age  |
+-----+-----+-----+
|1    |SPJ  |40   |
+-----+-----+-----+
|2    |Simon|41   |
+-----+-----+-----+
|3    |X    |999  |
+-----+-----+-----+

putMany

Arguments

:: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record)

=> [record]

A list of the records you want to insert or replace.

-> ReaderT backend m ()

Put many records into db

• insert new records that do not exist (or violate any unique constraints)
• replace existing records (matching any unique constraint)

Since: persistent-2.8.1

class PersistStoreRead backend => PersistUniqueRead backend where

Queries against Unique keys (other than the id Key).

Please read the general Persistent documentation to learn how to create Unique keys.

Using this with an Entity without a Unique key leads to undefined behavior. A few of these functions require a single Unique, so using an Entity with multiple Uniques is also undefined. In these cases persistent's goal is to throw an exception as soon as possible, but persistent is still transitioning to that.

SQL backends automatically create uniqueness constraints, but for MongoDB you must manually place a unique index on a field to have a uniqueness constraint.

Minimal complete definition

getBy

Methods

getBy :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m (Maybe (Entity record))

Get a record by unique key, if available. Returns also the identifier.

Example usage

With schema-1 and dataset-1:

getBySpjName :: MonadIO m  => ReaderT SqlBackend m (Maybe (Entity User))
getBySpjName = getBy $ UniqueUserName "SPJ"

mSpjEnt <- getBySpjName

The above query when applied on dataset-1, will get this entity:

+----+------+-----+
| id | name | age |
+----+------+-----+
|  1 | SPJ  |  40 |
+----+------+-----+

existsBy :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m Bool

Returns True if a record with this unique key exists, otherwise False.

Example usage

With schema-1 and dataset-1:

existsBySpjName :: MonadIO m  => ReaderT SqlBackend m Bool
existsBySpjName = existsBy $ UniqueUserName "SPJ"

spjEntExists <- existsBySpjName

The above query when applied on dataset-1, will return the value True.

Since: persistent-2.14.5

class (PersistQueryRead backend, PersistStoreWrite backend) => PersistQueryWrite backend where

Backends supporting conditional write operations

Methods

updateWhere :: forall (m :: Type -> Type) record. (MonadIO m, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> ReaderT backend m ()

Update individual fields on any record matching the given criterion.

deleteWhere :: forall (m :: Type -> Type) record. (MonadIO m, PersistRecordBackend record backend) => [Filter record] -> ReaderT backend m ()

Delete all records matching the given criterion.

class (PersistCore backend, PersistStoreRead backend) => PersistQueryRead backend where

Backends supporting conditional read operations.

Minimal complete definition

selectSourceRes, selectKeysRes, count, exists

Methods

selectSourceRes :: forall record (m1 :: Type -> Type) (m2 :: Type -> Type). (PersistRecordBackend record backend, MonadIO m1, MonadIO m2) => [Filter record] -> [SelectOpt record] -> ReaderT backend m1 (Acquire (ConduitM () (Entity record) m2 ()))

Get all records matching the given criterion in the specified order. Returns also the identifiers.

NOTE: This function returns an Acquire and a ConduitM, which implies that it streams from the database. It does not. Please use selectList to simplify the code. If you want streaming behavior, consider persistent-pagination which efficiently chunks a query into ranges, or investigate a backend-specific streaming solution.

selectFirst :: forall (m :: Type -> Type) record. (MonadIO m, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))

Get just the first record for the criterion.

selectKeysRes :: forall (m1 :: Type -> Type) (m2 :: Type -> Type) record. (MonadIO m1, MonadIO m2, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT backend m1 (Acquire (ConduitM () (Key record) m2 ()))

Get the Keys of all records matching the given criterion.

type PersistStore a = PersistStoreWrite a

A backwards-compatible alias for those that don't care about distinguishing between read and write queries. It signifies the assumption that, by default, a backend can write as well as read.

type PersistUnique a = PersistUniqueWrite a

A backwards-compatible alias for those that don't care about distinguishing between read and write queries. It signifies the assumption that, by default, a backend can write as well as read.

type IsSqlBackend backend = (IsPersistBackend backend, BaseBackend backend ~ SqlBackend)

A backend which is a wrapper around SqlBackend.

type SqlWriteT (m :: Type -> Type) a = forall backend. SqlBackendCanWrite backend => ReaderT backend m a

Like SqlPersistT but compatible with any SQL backend which can handle read and write queries.

type SqlReadT (m :: Type -> Type) a = forall backend. SqlBackendCanRead backend => ReaderT backend m a

Like SqlPersistT but compatible with any SQL backend which can handle read queries.

type SqlBackendCanWrite backend = (SqlBackendCanRead backend, PersistQueryWrite backend, PersistStoreWrite backend, PersistUniqueWrite backend)

A constraint synonym which witnesses that a backend is SQL and can run read and write queries.

type SqlBackendCanRead backend = (BackendCompatible SqlBackend backend, PersistQueryRead backend, PersistStoreRead backend, PersistUniqueRead backend)

A constraint synonym which witnesses that a backend is SQL and can run read queries.

newtype SqlWriteBackend

An SQL backend which can handle read or write queries

The constructor was exposed in 2.10.0

Constructors

SqlWriteBackend

Fields

• unSqlWriteBackend :: SqlBackend

Instances

HasPersistBackend SqlWriteBackend

Defined in Database.Persist.Sql.Types.Internal

Associated Types

type BaseBackend SqlWriteBackend

Methods

persistBackend :: SqlWriteBackend -> BaseBackend SqlWriteBackend

IsPersistBackend SqlWriteBackend

Defined in Database.Persist.Sql.Types.Internal

Methods

mkPersistBackend :: BaseBackend SqlWriteBackend -> SqlWriteBackend

newtype BackendKey SqlWriteBackend

Defined in Database.Persist.Sql.Orphan.PersistStore

newtype BackendKey SqlWriteBackend = SqlWriteBackendKey {

• unSqlWriteBackendKey :: Int64

}

type BaseBackend SqlWriteBackend

Defined in Database.Persist.Sql.Types.Internal

type BaseBackend SqlWriteBackend = SqlBackend

type Rep (BackendKey SqlWriteBackend)

Defined in Database.Persist.Sql.Orphan.PersistStore

type Rep (BackendKey SqlWriteBackend) = D1 ('MetaData "BackendKey" "Database.Persist.Sql.Orphan.PersistStore" "persistent-2.14.6.1-xgENLTHBf06k1BlJ0bdD3" 'True) (C1 ('MetaCons "SqlWriteBackendKey" 'PrefixI 'True) (S1 ('MetaSel ('Just "unSqlWriteBackendKey") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int64)))

newtype SqlReadBackend

An SQL backend which can only handle read queries

The constructor was exposed in 2.10.0.

Constructors

SqlReadBackend

Fields

• unSqlReadBackend :: SqlBackend

Instances

HasPersistBackend SqlReadBackend

Defined in Database.Persist.Sql.Types.Internal

Associated Types

type BaseBackend SqlReadBackend

Methods

persistBackend :: SqlReadBackend -> BaseBackend SqlReadBackend

IsPersistBackend SqlReadBackend

Defined in Database.Persist.Sql.Types.Internal

Methods

mkPersistBackend :: BaseBackend SqlReadBackend -> SqlReadBackend

newtype BackendKey SqlReadBackend

Defined in Database.Persist.Sql.Orphan.PersistStore

newtype BackendKey SqlReadBackend = SqlReadBackendKey {

• unSqlReadBackendKey :: Int64

}

type BaseBackend SqlReadBackend

Defined in Database.Persist.Sql.Types.Internal

type BaseBackend SqlReadBackend = SqlBackend

type Rep (BackendKey SqlReadBackend)

Defined in Database.Persist.Sql.Orphan.PersistStore

type Rep (BackendKey SqlReadBackend) = D1 ('MetaData "BackendKey" "Database.Persist.Sql.Orphan.PersistStore" "persistent-2.14.6.1-xgENLTHBf06k1BlJ0bdD3" 'True) (C1 ('MetaCons "SqlReadBackendKey" 'PrefixI 'True) (S1 ('MetaSel ('Just "unSqlReadBackendKey") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int64)))

data ConnectionPoolConfig

Values to configure a pool of database connections. See Data.Pool for details.

Since: persistent-2.11.0.0

Constructors

ConnectionPoolConfig

Fields

• connectionPoolConfigStripes :: Int

  How many stripes to divide the pool into. See Data.Pool for details. Default: 1.

• connectionPoolConfigIdleTimeout :: NominalDiffTime

  How long connections can remain idle before being disposed of, in seconds. Default: 600

• connectionPoolConfigSize :: Int

  How many connections should be held in the connection pool. Default: 10

Instances

Show ConnectionPoolConfig

Defined in Database.Persist.Sql.Types

Methods

showsPrec :: Int -> ConnectionPoolConfig -> ShowS

show :: ConnectionPoolConfig -> String

showList :: [ConnectionPoolConfig] -> ShowS

type ConnectionPool = Pool SqlBackend

type SqlPersistM = SqlPersistT (NoLoggingT (ResourceT IO))

type SqlPersistT = ReaderT SqlBackend

data PersistentSqlException

Constructors

StatementAlreadyFinalized Text

Couldn'tGetSQLConnection

Instances

Exception PersistentSqlException

Defined in Database.Persist.Sql.Types

Methods

toException :: PersistentSqlException -> SomeException

fromException :: SomeException -> Maybe PersistentSqlException

displayException :: PersistentSqlException -> String

Show PersistentSqlException

Defined in Database.Persist.Sql.Types

Methods

showsPrec :: Int -> PersistentSqlException -> ShowS

show :: PersistentSqlException -> String

showList :: [PersistentSqlException] -> ShowS

data ColumnReference

This value specifies how a field references another table.

Since: persistent-2.11.0.0

Constructors

ColumnReference

Fields

• crTableName :: !EntityNameDB

  The table name that the

  Since: persistent-2.11.0.0

• crConstraintName :: !ConstraintNameDB

  The name of the foreign key constraint.

  Since: persistent-2.11.0.0

• crFieldCascade :: !FieldCascade

  Whether or not updates/deletions to the referenced table cascade to this table.

  Since: persistent-2.11.0.0

Instances

Show ColumnReference

Defined in Database.Persist.Sql.Types

Methods

showsPrec :: Int -> ColumnReference -> ShowS

show :: ColumnReference -> String

showList :: [ColumnReference] -> ShowS

Eq ColumnReference

Defined in Database.Persist.Sql.Types

Methods

(==) :: ColumnReference -> ColumnReference -> Bool

(/=) :: ColumnReference -> ColumnReference -> Bool

Ord ColumnReference

Defined in Database.Persist.Sql.Types

Methods

compare :: ColumnReference -> ColumnReference -> Ordering

(<) :: ColumnReference -> ColumnReference -> Bool

(<=) :: ColumnReference -> ColumnReference -> Bool

(>) :: ColumnReference -> ColumnReference -> Bool

(>=) :: ColumnReference -> ColumnReference -> Bool

max :: ColumnReference -> ColumnReference -> ColumnReference

min :: ColumnReference -> ColumnReference -> ColumnReference

data BackendSpecificOverrides

Record of functions to override the default behavior in mkColumns. It is recommended you initialize this with emptyBackendSpecificOverrides and override the default values, so that as new fields are added, your code still compiles.

For added safety, use the getBackendSpecific* and setBackendSpecific* functions, as a breaking change to the record field labels won't be reflected in a major version bump of the library.

Since: persistent-2.11

class PersistField a => PersistFieldSql a where

Tells Persistent what database column type should be used to store a Haskell type.

Examples

Simple Boolean Alternative

data Switch = On | Off
  deriving (Show, Eq)

instance PersistField Switch where
  toPersistValue s = case s of
    On -> PersistBool True
    Off -> PersistBool False
  fromPersistValue (PersistBool b) = if b then Right On else Right Off
  fromPersistValue x = Left $ "File.hs: When trying to deserialize a Switch: expected PersistBool, received: " <> T.pack (show x)

instance PersistFieldSql Switch where
  sqlType _ = SqlBool

Non-Standard Database Types

If your database supports non-standard types, such as Postgres' uuid, you can use SqlOther to use them:

import qualified Data.UUID as UUID
instance PersistField UUID where
  toPersistValue = PersistLiteralEncoded . toASCIIBytes
  fromPersistValue (PersistLiteralEncoded uuid) =
    case fromASCIIBytes uuid of
      Nothing -> Left $ "Model/CustomTypes.hs: Failed to deserialize a UUID; received: " <> T.pack (show uuid)
      Just uuid' -> Right uuid'
  fromPersistValue x = Left $ "File.hs: When trying to deserialize a UUID: expected PersistLiteralEncoded, received: "-- >  <> T.pack (show x)

instance PersistFieldSql UUID where
  sqlType _ = SqlOther "uuid"

User Created Database Types

Similarly, some databases support creating custom types, e.g. Postgres' DOMAIN and ENUM features. You can use SqlOther to specify a custom type:

CREATE DOMAIN ssn AS text
      CHECK ( value ~ '^[0-9]{9}$');

instance PersistFieldSQL SSN where
  sqlType _ = SqlOther "ssn"

CREATE TYPE rainbow_color AS ENUM ('red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet');

instance PersistFieldSQL RainbowColor where
  sqlType _ = SqlOther "rainbow_color"

Methods

sqlType :: Proxy a -> SqlType

Instances

PersistFieldSql Int16

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Int16 -> SqlType

PersistFieldSql Int32

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Int32 -> SqlType

PersistFieldSql Int64

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Int64 -> SqlType

PersistFieldSql Int8

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Int8 -> SqlType

PersistFieldSql Rational

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Rational -> SqlType

PersistFieldSql Word16

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Word16 -> SqlType

PersistFieldSql Word32

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Word32 -> SqlType

PersistFieldSql Word64

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Word64 -> SqlType

PersistFieldSql Word8

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Word8 -> SqlType

PersistFieldSql Html

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Html -> SqlType

PersistFieldSql ByteString

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy ByteString -> SqlType

PersistFieldSql OverflowNatural

This type uses the SqlInt64 version, which will exhibit overflow and underflow behavior. Additionally, it permits negative values in the database, which isn't ideal.

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy OverflowNatural -> SqlType

PersistFieldSql PersistValue

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy PersistValue -> SqlType

PersistFieldSql Checkmark

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Checkmark -> SqlType

PersistFieldSql Text

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Text -> SqlType

PersistFieldSql Text

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Text -> SqlType

PersistFieldSql Day

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Day -> SqlType

PersistFieldSql UTCTime

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy UTCTime -> SqlType

PersistFieldSql TimeOfDay

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy TimeOfDay -> SqlType

PersistFieldSql Bool

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Bool -> SqlType

PersistFieldSql Double

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Double -> SqlType

PersistFieldSql Int

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Int -> SqlType

PersistFieldSql Word

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy Word -> SqlType

PersistFieldSql v => PersistFieldSql (IntMap v)

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy (IntMap v) -> SqlType

(Ord a, PersistFieldSql a) => PersistFieldSql (Set a)

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy (Set a) -> SqlType

(FromJSON a, ToJSON a) => PersistFieldSql (JSONB a)

jsonb

Since: 3.1.0

Defined in Database.Esqueleto.PostgreSQL.JSON.Instances

Methods

sqlType :: Proxy (JSONB a) -> SqlType

(PersistField record, PersistEntity record) => PersistFieldSql (Entity record)

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy (Entity record) -> SqlType

PersistFieldSql a => PersistFieldSql (Vector a)

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy (Vector a) -> SqlType

PersistFieldSql a => PersistFieldSql (Maybe a)

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy (Maybe a) -> SqlType

PersistFieldSql [Char]

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy [Char] -> SqlType

PersistFieldSql a => PersistFieldSql [a]

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy [a] -> SqlType

HasResolution a => PersistFieldSql (Fixed a)

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy (Fixed a) -> SqlType

PersistFieldSql v => PersistFieldSql (Map Text v)

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy (Map Text v) -> SqlType

(PersistFieldSql a, PersistFieldSql b) => PersistFieldSql (a, b)

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy (a, b) -> SqlType

newtype EntityWithPrefix (prefix :: Symbol) record

This newtype wrapper is useful when selecting an entity out of the database and you want to provide a prefix to the table being selected.

Consider this raw SQL query:

SELECT ??
FROM my_long_table_name AS mltn
INNER JOIN other_table AS ot
   ON mltn.some_col = ot.other_col
WHERE ...

We don't want to refer to my_long_table_name every time, so we create an alias. If we want to select it, we have to tell the raw SQL quasi-quoter that we expect the entity to be prefixed with some other name.

We can give the above query a type with this, like:

getStuff :: SqlPersistM [EntityWithPrefix "mltn" MyLongTableName]
getStuff = rawSql queryText []

The EntityWithPrefix bit is a boilerplate newtype wrapper, so you can remove it with unPrefix, like this:

getStuff :: SqlPersistM [Entity MyLongTableName]
getStuff = unPrefix @"mltn" <$> rawSql queryText []

The symbol is a "type application" and requires the TypeApplications@ language extension.

Since: persistent-2.10.5

Constructors

EntityWithPrefix

Fields

• unEntityWithPrefix :: Entity record

Instances

(PersistEntity record, KnownSymbol prefix, PersistEntityBackend record ~ backend, IsPersistBackend backend) => RawSql (EntityWithPrefix prefix record)

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> EntityWithPrefix prefix record -> (Int, [Text])

rawSqlColCountReason :: EntityWithPrefix prefix record -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (EntityWithPrefix prefix record)

class RawSql a where

Class for data types that may be retrived from a rawSql query.

Methods

rawSqlCols :: (Text -> Text) -> a -> (Int, [Text])

Number of columns that this data type needs and the list of substitutions for SELECT placeholders ??.

rawSqlColCountReason :: a -> String

A string telling the user why the column count is what it is.

rawSqlProcessRow :: [PersistValue] -> Either Text a

Transform a row of the result into the data type.

Instances

(PersistEntity record, PersistEntityBackend record ~ backend, IsPersistBackend backend) => RawSql (Entity record)

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> Entity record -> (Int, [Text])

rawSqlColCountReason :: Entity record -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (Entity record)

(PersistEntity a, PersistEntityBackend a ~ backend, IsPersistBackend backend) => RawSql (Key a)

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> Key a -> (Int, [Text])

rawSqlColCountReason :: Key a -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (Key a)

PersistField a => RawSql (Single a)

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> Single a -> (Int, [Text])

rawSqlColCountReason :: Single a -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (Single a)

RawSql a => RawSql (Maybe a)

Since: persistent-1.0.1

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> Maybe a -> (Int, [Text])

rawSqlColCountReason :: Maybe a -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (Maybe a)

(PersistEntity record, KnownSymbol prefix, PersistEntityBackend record ~ backend, IsPersistBackend backend) => RawSql (EntityWithPrefix prefix record)

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> EntityWithPrefix prefix record -> (Int, [Text])

rawSqlColCountReason :: EntityWithPrefix prefix record -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (EntityWithPrefix prefix record)

(RawSql a, RawSql b) => RawSql (a, b)

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b) -> (Int, [Text])

rawSqlColCountReason :: (a, b) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b)

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

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c)

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

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d)

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

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e)

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

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f)

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

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g)

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

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h)

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

Since: persistent-2.10.2

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j) => RawSql (a, b, c, d, e, f, g, h, i, j)

Since: persistent-2.10.2

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k) => RawSql (a, b, c, d, e, f, g, h, i, j, k)

Since: persistent-2.10.2

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l)

Since: persistent-2.10.2

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3, RawSql c3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3, RawSql c3, RawSql d3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3, RawSql c3, RawSql d3, RawSql e3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3, RawSql c3, RawSql d3, RawSql e3, RawSql f3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3, RawSql c3, RawSql d3, RawSql e3, RawSql f3, RawSql g3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3, RawSql c3, RawSql d3, RawSql e3, RawSql f3, RawSql g3, RawSql h3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3, RawSql c3, RawSql d3, RawSql e3, RawSql f3, RawSql g3, RawSql h3, RawSql i3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3, i3)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3, i3) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3, i3) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3, i3)

(RawSql a, RawSql b, RawSql c, RawSql d, RawSql e, RawSql f, RawSql g, RawSql h, RawSql i, RawSql j, RawSql k, RawSql l, RawSql m, RawSql n, RawSql o, RawSql p, RawSql q, RawSql r, RawSql s, RawSql t, RawSql u, RawSql v, RawSql w, RawSql x, RawSql y, RawSql z, RawSql a2, RawSql b2, RawSql c2, RawSql d2, RawSql e2, RawSql f2, RawSql g2, RawSql h2, RawSql i2, RawSql j2, RawSql k2, RawSql l2, RawSql m2, RawSql n2, RawSql o2, RawSql p2, RawSql q2, RawSql r2, RawSql s2, RawSql t2, RawSql u2, RawSql v2, RawSql w2, RawSql x2, RawSql y2, RawSql z2, RawSql a3, RawSql b3, RawSql c3, RawSql d3, RawSql e3, RawSql f3, RawSql g3, RawSql h3, RawSql i3, RawSql j3) => RawSql (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3, i3, j3)

Since: persistent-2.11.0

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3, i3, j3) -> (Int, [Text])

rawSqlColCountReason :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3, i3, j3) -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2, t2, u2, v2, w2, x2, y2, z2, a3, b3, c3, d3, e3, f3, g3, h3, i3, j3)

data FilterTablePrefix

Used when determining how to prefix a column name in a WHERE clause.

Since: persistent-2.12.1.0

Constructors

PrefixTableName

Prefix the column with the table name. This is useful if the column name might be ambiguous.

Since: persistent-2.12.1.0

PrefixExcluded

Prefix the column name with the EXCLUDED keyword. This is used with the Postgresql backend when doing ON CONFLICT DO UPDATE clauses - see the documentation on upsertWhere and upsertManyWhere.

Since: persistent-2.12.1.0

newtype PersistUnsafeMigrationException

An exception indicating that Persistent refused to run some unsafe migrations. Contains a list of pairs where the Bool tracks whether the migration was unsafe (True means unsafe), and the Sql is the sql statement for the migration.

Since: persistent-2.11.1.0

Constructors

PersistUnsafeMigrationException [(Bool, Sql)]

Instances

Exception PersistUnsafeMigrationException

Defined in Database.Persist.Sql.Migration

Methods

toException :: PersistUnsafeMigrationException -> SomeException

fromException :: SomeException -> Maybe PersistUnsafeMigrationException

displayException :: PersistUnsafeMigrationException -> String

Show PersistUnsafeMigrationException

This Show instance renders an error message suitable for printing to the console. This is a little dodgy, but since GHC uses Show instances when displaying uncaught exceptions, we have little choice.

Defined in Database.Persist.Sql.Migration

Methods

showsPrec :: Int -> PersistUnsafeMigrationException -> ShowS

show :: PersistUnsafeMigrationException -> String

showList :: [PersistUnsafeMigrationException] -> ShowS

type Migration = WriterT [Text] (WriterT CautiousMigration (ReaderT SqlBackend IO)) ()

A Migration is a four level monad stack consisting of:

• WriterT [Text] representing a log of errors in the migrations.
• WriterT CautiousMigration representing a list of migrations to run, along with whether or not they are safe.
• ReaderT SqlBackend, aka the SqlPersistT transformer for database interop.
• IO for arbitrary IO.

type CautiousMigration = [(Bool, Sql)]

A list of SQL operations, marked with a safety flag. If the Bool is True, then the operation is *unsafe* - it might be destructive, or otherwise not idempotent. If the Bool is False, then the operation is *safe*, and can be run repeatedly without issues.

type Sql = Text

insertBy :: forall record backend (m :: Type -> Type). (MonadIO m, PersistUniqueWrite backend, PersistRecordBackend record backend, AtLeastOneUniqueKey record, SafeToInsert record) => record -> ReaderT backend m (Either (Entity record) (Key record))

Insert a value, checking for conflicts with any unique constraints. If a duplicate exists in the database, it is returned as Left. Otherwise, the new 'Key is returned as Right.

Example usage

With schema-2 and dataset-1, we have following lines of code:

l1 <- insertBy $ User "SPJ" 20
l2 <- insertBy $ User "XXX" 41
l3 <- insertBy $ User "SPJ" 40
r1 <- insertBy $ User "XXX" 100

First three lines return Left because there're duplicates in given record's uniqueness constraints. While the last line returns a new key as Right.

reportError :: Text -> Migration

Report a single error in a Migration.

Since: persistent-2.9.2

migrate :: [EntityDef] -> EntityDef -> Migration

Given a list of old entity definitions and a new EntityDef in val, this creates a Migration to update the old list of definitions with the new one.

close' :: BackendCompatible SqlBackend backend => backend -> IO ()

rawSql

Arguments

:: forall a (m :: Type -> Type) backend. (RawSql a, MonadIO m, BackendCompatible SqlBackend backend)

=> Text

SQL statement, possibly with placeholders.

-> [PersistValue]

Values to fill the placeholders.

-> ReaderT backend m [a]

Execute a raw SQL statement and return its results as a list. If you do not expect a return value, use of rawExecute is recommended.

If you're using Entitys (which is quite likely), then you must use entity selection placeholders (double question mark, ??). These ?? placeholders are then replaced for the names of the columns that we need for your entities. You'll receive an error if you don't use the placeholders. Please see the Entitys documentation for more details.

You may put value placeholders (question marks, ?) in your SQL query. These placeholders are then replaced by the values you pass on the second parameter, already correctly escaped. You may want to use toPersistValue to help you constructing the placeholder values.

Since you're giving a raw SQL statement, you don't get any guarantees regarding safety. If rawSql is not able to parse the results of your query back, then an exception is raised. However, most common problems are mitigated by using the entity selection placeholder ??, and you shouldn't see any error at all if you're not using Single.

Some example of rawSql based on this schema:

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase|
Person
    name String
    age Int Maybe
    deriving Show
BlogPost
    title String
    authorId PersonId
    deriving Show
|]

Examples based on the above schema:

getPerson :: MonadIO m => ReaderT SqlBackend m [Entity Person]
getPerson = rawSql "select ?? from person where name=?" [PersistText "john"]

getAge :: MonadIO m => ReaderT SqlBackend m [Single Int]
getAge = rawSql "select person.age from person where name=?" [PersistText "john"]

getAgeName :: MonadIO m => ReaderT SqlBackend m [(Single Int, Single Text)]
getAgeName = rawSql "select person.age, person.name from person where name=?" [PersistText "john"]

getPersonBlog :: MonadIO m => ReaderT SqlBackend m [(Entity Person, Entity BlogPost)]
getPersonBlog = rawSql "select ??,?? from person,blog_post where person.id = blog_post.author_id" []

Minimal working program for PostgreSQL backend based on the above concepts:

{-# LANGUAGE EmptyDataDecls             #-}
{-# LANGUAGE FlexibleContexts           #-}
{-# LANGUAGE GADTs                      #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses      #-}
{-# LANGUAGE OverloadedStrings          #-}
{-# LANGUAGE QuasiQuotes                #-}
{-# LANGUAGE TemplateHaskell            #-}
{-# LANGUAGE TypeFamilies               #-}

import           Control.Monad.IO.Class  (liftIO)
import           Control.Monad.Logger    (runStderrLoggingT)
import           Database.Persist
import           Control.Monad.Reader
import           Data.Text
import           Database.Persist.Sql
import           Database.Persist.Postgresql
import           Database.Persist.TH

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase|
Person
    name String
    age Int Maybe
    deriving Show
|]

conn = "host=localhost dbname=new_db user=postgres password=postgres port=5432"

getPerson :: MonadIO m => ReaderT SqlBackend m [Entity Person]
getPerson = rawSql "select ?? from person where name=?" [PersistText "sibi"]

liftSqlPersistMPool y x = liftIO (runSqlPersistMPool y x)

main :: IO ()
main = runStderrLoggingT $ withPostgresqlPool conn 10 $ liftSqlPersistMPool $ do
         runMigration migrateAll
         xs <- getPerson
         liftIO (print xs)

fromPersistValueText :: PersistValue -> Either Text Text

fieldAttrsContainsNullable :: [FieldAttr] -> IsNullable

entitiesPrimary :: EntityDef -> NonEmpty FieldDef

Return the [FieldDef] for the entity keys.

entityPrimary :: EntityDef -> Maybe CompositeDef

keyAndEntityFields :: EntityDef -> NonEmpty FieldDef

Returns a NonEmpty list of FieldDef that correspond with the key columns for an EntityDef.

parseFieldAttrs :: [Text] -> [FieldAttr]

Parse raw field attributes into structured form. Any unrecognized attributes will be preserved, identically as they are encountered, as FieldAttrOther values.

Since: persistent-2.11.0.0

isFieldNotGenerated :: FieldDef -> Bool

isHaskellField :: FieldDef -> Bool

Returns True if the FieldDef does not have a MigrationOnly or SafeToRemove flag from the QuasiQuoter.

Since: persistent-2.13.0.0

noCascade :: FieldCascade

A FieldCascade that does nothing.

Since: persistent-2.11.0

renderFieldCascade :: FieldCascade -> Text

Renders a FieldCascade value such that it can be used in SQL migrations.

Since: persistent-2.11.0

renderCascadeAction :: CascadeAction -> Text

Render a CascadeAction to Text such that it can be used in a SQL command.

Since: persistent-2.11.0

setFieldAttrs :: [FieldAttr] -> FieldDef -> FieldDef

Replace the FieldDef FieldAttr with the new list.

Since: persistent-2.13.0.0

overFieldAttrs :: ([FieldAttr] -> [FieldAttr]) -> FieldDef -> FieldDef

Modify the list of field attributes.

Since: persistent-2.13.0.0

addFieldAttr :: FieldAttr -> FieldDef -> FieldDef

Add an attribute to the list of field attributes.

Since: persistent-2.13.0.0

isFieldNullable :: FieldDef -> IsNullable

Check if the field definition is nullable

Since: persistent-2.13.0.0

isFieldMaybe :: FieldDef -> Bool

Check if the field is `Maybe a`

Since: persistent-2.13.0.0

getEntityUniquesNoPrimaryKey :: EntityDef -> [UniqueDef]

Retrieve the list of UniqueDef from an EntityDef. This does not include a Primary key, if one is defined. A future version of persistent will include a Primary key among the Unique constructors for the Entity.

Since: persistent-2.14.0.0

getEntityUniques :: EntityDef -> [UniqueDef]

Retrieve the list of UniqueDef from an EntityDef. As of version 2.14, this will also include the primary key on the entity, if one is defined. If you do not want the primary key, see getEntityUniquesNoPrimaryKey.

Since: persistent-2.13.0.0

getEntityHaskellName :: EntityDef -> EntityNameHS

Retrieve the Haskell name of the given entity.

Since: persistent-2.13.0.0

getEntityDBName :: EntityDef -> EntityNameDB

Return the database name for the given entity.

Since: persistent-2.13.0.0

getEntityExtra :: EntityDef -> Map Text [[Text]]

setEntityDBName :: EntityNameDB -> EntityDef -> EntityDef

Since: persistent-2.13.0.0

getEntityComments :: EntityDef -> Maybe Text

getEntityForeignDefs :: EntityDef -> [ForeignDef]

Since: persistent-2.13.0.0

getEntityFields :: EntityDef -> [FieldDef]

Retrieve the list of FieldDef that makes up the fields of the entity.

This does not return the fields for an Id column or an implicit id. It will return the key columns if you used the Primary syntax for defining the primary key.

This does not return fields that are marked SafeToRemove or MigrationOnly - so it only returns fields that are represented in the Haskell type. If you need those fields, use getEntityFieldsDatabase.

Since: persistent-2.13.0.0

getEntityFieldsDatabase :: EntityDef -> [FieldDef]

This returns all of the FieldDef defined for the EntityDef, including those fields that are marked as MigrationOnly (and therefore only present in the database) or SafeToRemove (and a migration will drop the column if it exists in the database).

For all the fields that are present on the Haskell-type, see getEntityFields.

Since: persistent-2.13.0.0

isEntitySum :: EntityDef -> Bool

Since: persistent-2.13.0.0

getEntityId :: EntityDef -> EntityIdDef

Since: persistent-2.13.0.0

getEntityIdField :: EntityDef -> Maybe FieldDef

Since: persistent-2.13.0.0

setEntityId :: FieldDef -> EntityDef -> EntityDef

Set an entityId to be the given FieldDef.

Since: persistent-2.13.0.0

setEntityIdDef :: EntityIdDef -> EntityDef -> EntityDef

Since: persistent-2.13.0.0

getEntityKeyFields :: EntityDef -> NonEmpty FieldDef

Since: persistent-2.13.0.0

overEntityFields :: ([FieldDef] -> [FieldDef]) -> EntityDef -> EntityDef

Perform a mapping function over all of the entity fields, as determined by getEntityFieldsDatabase.

Since: persistent-2.13.0.0

tabulateEntity :: PersistEntity record => (forall a. EntityField record a -> a) -> Entity record

Construct an Entity record by providing a value for each of the record's fields.

These constructions are equivalent:

entityMattConstructor, entityMattTabulate :: Entity User
entityMattConstructor =
    Entity
        { entityKey = toSqlKey 123
        , entityVal =
            User
                { userName = Matt
                , userAge = 33
                }
        }

entityMattTabulate =
    tabulateEntity $ \case
        UserId ->
            toSqlKey 123
        UserName ->
            Matt
        UserAge ->
            33

This is a specialization of tabulateEntityA, which allows you to construct an Entity by providing an Applicative action for each field instead of a regular function.

Since: persistent-2.14.0.0

entityValues :: PersistEntity record => Entity record -> [PersistValue]

Get list of values corresponding to given entity.

keyValueEntityToJSON :: (PersistEntity record, ToJSON record) => Entity record -> Value

Predefined toJSON. The resulting JSON looks like {"key": 1, "value": {"name": ...}}.

The typical usage is:

instance ToJSON (Entity User) where
    toJSON = keyValueEntityToJSON

keyValueEntityFromJSON :: (PersistEntity record, FromJSON record) => Value -> Parser (Entity record)

Predefined parseJSON. The input JSON looks like {"key": 1, "value": {"name": ...}}.

The typical usage is:

instance FromJSON (Entity User) where
    parseJSON = keyValueEntityFromJSON

entityIdToJSON :: (PersistEntity record, ToJSON record) => Entity record -> Value

Predefined toJSON. The resulting JSON looks like {"id": 1, "name": ...}.

The typical usage is:

instance ToJSON (Entity User) where
    toJSON = entityIdToJSON

entityIdFromJSON :: (PersistEntity record, FromJSON record) => Value -> Parser (Entity record)

Predefined parseJSON. The input JSON looks like {"id": 1, "name": ...}.

The typical usage is:

instance FromJSON (Entity User) where
    parseJSON = entityIdFromJSON

toPersistValueJSON :: ToJSON a => a -> PersistValue

Convenience function for getting a free PersistField instance from a type with JSON instances.

Example usage in combination with fromPersistValueJSON:

instance PersistField MyData where
  fromPersistValue = fromPersistValueJSON
  toPersistValue = toPersistValueJSON

fromPersistValueJSON :: FromJSON a => PersistValue -> Either Text a

Convenience function for getting a free PersistField instance from a type with JSON instances. The JSON parser used will accept JSON values other that object and arrays. So, if your instance serializes the data to a JSON string, this will still work.

Example usage in combination with toPersistValueJSON:

instance PersistField MyData where
  fromPersistValue = fromPersistValueJSON
  toPersistValue = toPersistValueJSON

withBaseBackend :: forall backend (m :: Type -> Type) a. HasPersistBackend backend => ReaderT (BaseBackend backend) m a -> ReaderT backend m a

Run a query against a larger backend by plucking out BaseBackend backend

This is a helper for reusing existing queries when expanding the backend type.

Since: persistent-2.12.0

withCompatibleBackend :: forall sup sub (m :: Type -> Type) a. BackendCompatible sup sub => ReaderT sup m a -> ReaderT sub m a

Run a query against a compatible backend, by projecting the backend

This is a helper for using queries which run against a specific backend type that your backend is compatible with.

Since: persistent-2.12.0

liftPersist :: (MonadIO m, MonadReader backend m) => ReaderT backend IO b -> m b

getJust :: forall record backend (m :: Type -> Type). (PersistStoreRead backend, PersistRecordBackend record backend, MonadIO m) => Key record -> ReaderT backend m record

Same as get, but for a non-null (not Maybe) foreign key. Unsafe unless your database is enforcing that the foreign key is valid.

Example usage

With schema-1 and dataset-1,

getJustSpj :: MonadIO m => ReaderT SqlBackend m User
getJustSpj = getJust spjId

spj <- getJust spjId

The above query when applied on dataset-1, will get this record:

+----+------+-----+
| id | name | age |
+----+------+-----+
|  1 | SPJ  |  40 |
+----+------+-----+

getJustUnknown :: MonadIO m => ReaderT SqlBackend m User
getJustUnknown = getJust unknownId

mrx <- getJustUnknown

This just throws an error.

getJustEntity :: forall record backend (m :: Type -> Type). (PersistEntityBackend record ~ BaseBackend backend, MonadIO m, PersistEntity record, PersistStoreRead backend) => Key record -> ReaderT backend m (Entity record)

Same as getJust, but returns an Entity instead of just the record.

Example usage

With schema-1 and dataset-1,

getJustEntitySpj :: MonadIO m => ReaderT SqlBackend m (Entity User)
getJustEntitySpj = getJustEntity spjId

spjEnt <- getJustEntitySpj

The above query when applied on dataset-1, will get this entity:

+----+------+-----+
| id | name | age |
+----+------+-----+
|  1 | SPJ  |  40 |
+----+------+-----+

Since: persistent-2.6.1

belongsTo :: forall ent1 ent2 backend (m :: Type -> Type). (PersistStoreRead backend, PersistEntity ent1, PersistRecordBackend ent2 backend, MonadIO m) => (ent1 -> Maybe (Key ent2)) -> ent1 -> ReaderT backend m (Maybe ent2)

Curry this to make a convenience function that loads an associated model.

foreign = belongsTo foreignId

belongsToJust :: forall ent1 ent2 backend (m :: Type -> Type). (PersistStoreRead backend, PersistEntity ent1, PersistRecordBackend ent2 backend, MonadIO m) => (ent1 -> Key ent2) -> ent1 -> ReaderT backend m ent2

Same as belongsTo, but uses getJust and therefore is similarly unsafe.

insertEntity :: forall e backend (m :: Type -> Type). (PersistStoreWrite backend, PersistRecordBackend e backend, SafeToInsert e, MonadIO m, HasCallStack) => e -> ReaderT backend m (Entity e)

Like insert, but returns the complete Entity.

Example usage

With schema-1 and dataset-1,

insertHaskellEntity :: MonadIO m => ReaderT SqlBackend m (Entity User)
insertHaskellEntity = insertEntity $ User "Haskell" 81

haskellEnt <- insertHaskellEntity

The above query when applied on dataset-1, will produce this:

+----+---------+-----+
| id |  name   | age |
+----+---------+-----+
|  1 | SPJ     |  40 |
+----+---------+-----+
|  2 | Simon   |  41 |
+----+---------+-----+
|  3 | Haskell |  81 |
+----+---------+-----+

getEntity :: forall e backend (m :: Type -> Type). (PersistStoreRead backend, PersistRecordBackend e backend, MonadIO m) => Key e -> ReaderT backend m (Maybe (Entity e))

Like get, but returns the complete Entity.

Example usage

With schema-1 and dataset-1,

getSpjEntity :: MonadIO m => ReaderT SqlBackend m (Maybe (Entity User))
getSpjEntity = getEntity spjId

mSpjEnt <- getSpjEntity

The above query when applied on dataset-1, will get this entity:

+----+------+-----+
| id | name | age |
+----+------+-----+
|  1 | SPJ  |  40 |
+----+------+-----+

insertRecord :: forall record backend (m :: Type -> Type). (PersistEntityBackend record ~ BaseBackend backend, PersistEntity record, MonadIO m, PersistStoreWrite backend, SafeToInsert record, HasCallStack) => record -> ReaderT backend m record

Like insertEntity but just returns the record instead of Entity.

Example usage

With schema-1 and dataset-1,

insertDaveRecord :: MonadIO m => ReaderT SqlBackend m User
insertDaveRecord = insertRecord $ User "Dave" 50

dave <- insertDaveRecord

The above query when applied on dataset-1, will produce this:

+-----+------+-----+
|id   |name  |age  |
+-----+------+-----+
|1    |SPJ   |40   |
+-----+------+-----+
|2    |Simon |41   |
+-----+------+-----+
|3    |Dave  |50   |
+-----+------+-----+

Since: persistent-2.6.1

onlyOneUniqueDef :: (OnlyOneUniqueKey record, Monad proxy) => proxy record -> UniqueDef

Given a proxy for a PersistEntity record, this returns the sole UniqueDef for that entity.

Since: persistent-2.13.0.0

insertUniqueEntity :: forall record backend (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, PersistUniqueWrite backend, SafeToInsert record) => record -> ReaderT backend m (Maybe (Entity record))

Like insertEntity, but returns Nothing when the record couldn't be inserted because of a uniqueness constraint.

Example usage

We use schema-2 and dataset-1 here.

insertUniqueSpjEntity :: MonadIO m => ReaderT SqlBackend m (Maybe (Entity User))
insertUniqueSpjEntity = insertUniqueEntity $ User "SPJ" 50

mSpjEnt <- insertUniqueSpjEntity

The above query results Nothing as SPJ already exists.

insertUniqueAlexaEntity :: MonadIO m => ReaderT SqlBackend m (Maybe (Entity User))
insertUniqueAlexaEntity = insertUniqueEntity $ User "Alexa" 3

mAlexaEnt <- insertUniqueSpjEntity

Because there's no such unique keywords of the given record, the above query when applied on dataset-1, will produce this:

+----+-------+-----+
| id | name  | age |
+----+-------+-----+
|  1 | SPJ   |  40 |
+----+-------+-----+
|  2 | Simon |  41 |
+----+-------+-----+
|  3 | Alexa |   3 |
+----+-------+-----+

Since: persistent-2.7.1

onlyUnique :: forall record backend (m :: Type -> Type). (MonadIO m, PersistUniqueWrite backend, PersistRecordBackend record backend, OnlyOneUniqueKey record) => record -> ReaderT backend m (Unique record)

Return the single unique key for a record.

Example usage

We use shcema-1 and dataset-1 here.

onlySimonConst :: MonadIO m => ReaderT SqlBackend m (Unique User)
onlySimonConst = onlyUnique $ User "Simon" 999

mSimonConst <- onlySimonConst

mSimonConst would be Simon's uniqueness constraint. Note that onlyUnique doesn't work if there're more than two constraints. It will fail with a type error instead.

getByValue :: forall record (m :: Type -> Type) backend. (MonadIO m, PersistUniqueRead backend, PersistRecordBackend record backend, AtLeastOneUniqueKey record) => record -> ReaderT backend m (Maybe (Entity record))

A modification of getBy, which takes the PersistEntity itself instead of a Unique record. Returns a record matching one of the unique keys. This function makes the most sense on entities with a single Unique constructor.

Example usage

With schema-1 and dataset-1,

getBySpjValue :: MonadIO m => ReaderT SqlBackend m (Maybe (Entity User)) getBySpjValue = getByValue $ User SPJ 999

mSpjEnt <- getBySpjValue

The above query when applied on dataset-1, will get this record:

+----+------+-----+
| id | name | age |
+----+------+-----+
|  1 | SPJ  |  40 |
+----+------+-----+

replaceUnique :: forall record backend (m :: Type -> Type). (MonadIO m, Eq (Unique record), PersistRecordBackend record backend, PersistUniqueWrite backend) => Key record -> record -> ReaderT backend m (Maybe (Unique record))

Attempt to replace the record of the given key with the given new record. First query the unique fields to make sure the replacement maintains uniqueness constraints.

Return Nothing if the replacement was made. If uniqueness is violated, return a Just with the Unique violation

Since: persistent-1.2.2.0

checkUnique :: forall record backend (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, PersistUniqueRead backend) => record -> ReaderT backend m (Maybe (Unique record))

Check whether there are any conflicts for unique keys with this entity and existing entities in the database.

Returns Nothing if the entity would be unique, and could thus safely be inserted. on a conflict returns the conflicting key

Example usage

We use schema-1 and dataset-1 here.

This would be Nothing:

mAlanConst <- checkUnique $ User "Alan" 70

While this would be Just because SPJ already exists:

mSpjConst <- checkUnique $ User "SPJ" 60

checkUniqueUpdateable :: forall record backend (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, PersistUniqueRead backend) => Entity record -> ReaderT backend m (Maybe (Unique record))

Check whether there are any conflicts for unique keys with this entity and existing entities in the database.

Returns Nothing if the entity would stay unique, and could thus safely be updated. on a conflict returns the conflicting key

This is similar to checkUnique, except it's useful for updating - when the particular entity already exists, it would normally conflict with itself. This variant ignores those conflicts

Example usage

We use schema-1 and dataset-1 here.

This would be Nothing:

mAlanConst <- checkUnique $ User "Alan" 70

While this would be Just because SPJ already exists:

mSpjConst <- checkUnique $ User "SPJ" 60

Since: persistent-2.11.0.0

selectKeys :: forall record backend (m :: Type -> Type). (PersistQueryRead backend, MonadResource m, PersistRecordBackend record backend, MonadReader backend m) => [Filter record] -> [SelectOpt record] -> ConduitM () (Key record) m ()

Get the Keys of all records matching the given criterion.

For an example, see selectList.

writeToUnknown :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlWriteBackend m a -> ReaderT SqlBackend m a

Useful for running a write query against an untagged backend with unknown capabilities.

readToWrite :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlReadBackend m a -> ReaderT SqlWriteBackend m a

Useful for running a read query against a backend with read and write capabilities.

readToUnknown :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlReadBackend m a -> ReaderT SqlBackend m a

Useful for running a read query against a backend with unknown capabilities.

defaultConnectionPoolConfig :: ConnectionPoolConfig

Initializes a ConnectionPoolConfig with default values. See the documentation of ConnectionPoolConfig for each field's default value.

Since: persistent-2.11.0.0

getBackendSpecificForeignKeyName :: BackendSpecificOverrides -> Maybe (EntityNameDB -> FieldNameDB -> ConstraintNameDB)

If the override is defined, then this returns a function that accepts an entity name and field name and provides the ConstraintNameDB for the foreign key constraint.

An abstract accessor for the BackendSpecificOverrides

Since: persistent-2.13.0.0

setBackendSpecificForeignKeyName :: (EntityNameDB -> FieldNameDB -> ConstraintNameDB) -> BackendSpecificOverrides -> BackendSpecificOverrides

Set the backend's foreign key generation function to this value.

Since: persistent-2.13.0.0

emptyBackendSpecificOverrides :: BackendSpecificOverrides

Creates an empty BackendSpecificOverrides (i.e. use the default behavior; no overrides)

Since: persistent-2.11

defaultAttribute :: [FieldAttr] -> Maybe Text

mkColumns :: [EntityDef] -> EntityDef -> BackendSpecificOverrides -> ([Column], [UniqueDef], [ForeignDef])

Create the list of columns for the given entity.

toJsonText :: ToJSON j => j -> Text

A more general way to convert instances of ToJSON type class to strict text Text.

unPrefix :: forall (prefix :: Symbol) record. EntityWithPrefix prefix record -> Entity record

A helper function to tell GHC what the EntityWithPrefix prefix should be. This allows you to use a type application to specify the prefix, instead of specifying the etype on the result.

As an example, here's code that uses this:

myQuery :: SqlPersistM [Entity Person]
myQuery = fmap (unPrefix @"p") $ rawSql query []
  where
    query = "SELECT ?? FROM person AS p"

Since: persistent-2.10.5

rawQuery :: forall (m :: Type -> Type) env. (MonadResource m, MonadReader env m, BackendCompatible SqlBackend env) => Text -> [PersistValue] -> ConduitM () [PersistValue] m ()

rawQueryRes :: forall (m1 :: Type -> Type) (m2 :: Type -> Type) env. (MonadIO m1, MonadIO m2, BackendCompatible SqlBackend env) => Text -> [PersistValue] -> ReaderT env m1 (Acquire (ConduitM () [PersistValue] m2 ()))

rawExecute

Arguments

:: forall (m :: Type -> Type) backend. (MonadIO m, BackendCompatible SqlBackend backend)

=> Text

SQL statement, possibly with placeholders.

-> [PersistValue]

Values to fill the placeholders.

-> ReaderT backend m ()

Execute a raw SQL statement

rawExecuteCount

Arguments

:: forall (m :: Type -> Type) backend. (MonadIO m, BackendCompatible SqlBackend backend)

=> Text

SQL statement, possibly with placeholders.

-> [PersistValue]

Values to fill the placeholders.

-> ReaderT backend m Int64

Execute a raw SQL statement and return the number of rows it has modified.

getStmtConn :: SqlBackend -> Text -> IO Statement

runSqlPool :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> m a

Get a connection from the pool, run the given action, and then return the connection to the pool.

This function performs the given action in a transaction. If an exception occurs during the action, then the transaction is rolled back.

Note: This function previously timed out after 2 seconds, but this behavior was buggy and caused more problems than it solved. Since version 2.1.2, it performs no timeout checks.

runSqlPoolWithIsolation :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> IsolationLevel -> m a

Like runSqlPool, but supports specifying an isolation level.

Since: persistent-2.9.0

runSqlPoolNoTransaction :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> m a

Like runSqlPool, but does not surround the action in a transaction. This action might leave your database in a weird state.

Since: persistent-2.12.0.0

runSqlPoolWithHooks

Arguments

:: forall backend m a before after onException. (MonadUnliftIO m, BackendCompatible SqlBackend backend)

=> ReaderT backend m a

-> Pool backend

-> Maybe IsolationLevel

-> (backend -> m before)

Run this action immediately before the action is performed.

-> (backend -> m after)

Run this action immediately after the action is completed.

-> (backend -> SomeException -> m onException)

This action is performed when an exception is received. The exception is provided as a convenience - it is rethrown once this cleanup function is complete.

-> m a

This function is how runSqlPool and runSqlPoolNoTransaction are defined. In addition to the action to be performed and the Pool of conections to use, we give you the opportunity to provide three actions - initialize, afterwards, and onException.

Since: persistent-2.12.0.0

runSqlPoolWithExtensibleHooks :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> SqlPoolHooks m backend -> m a

This function is how runSqlPoolWithHooks is defined.

It's currently the most general function for using a SQL pool.

Since: persistent-2.13.0.0

acquireSqlConn :: (MonadReader backend m, BackendCompatible SqlBackend backend) => m (Acquire backend)

Starts a new transaction on the connection. When the acquired connection is released the transaction is committed and the connection returned to the pool.

Upon an exception the transaction is rolled back and the connection destroyed.

This is equivalent to runSqlConn but does not incur the MonadUnliftIO constraint, meaning it can be used within, for example, a Conduit pipeline.

Since: persistent-2.10.5

acquireSqlConnWithIsolation :: (MonadReader backend m, BackendCompatible SqlBackend backend) => IsolationLevel -> m (Acquire backend)

Like acquireSqlConn, but lets you specify an explicit isolation level.

Since: persistent-2.10.5

runSqlConn :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> backend -> m a

runSqlConnWithIsolation :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> backend -> IsolationLevel -> m a

Like runSqlConn, but supports specifying an isolation level.

Since: persistent-2.9.0

runSqlPersistM :: BackendCompatible SqlBackend backend => ReaderT backend (NoLoggingT (ResourceT IO)) a -> backend -> IO a

runSqlPersistMPool :: BackendCompatible SqlBackend backend => ReaderT backend (NoLoggingT (ResourceT IO)) a -> Pool backend -> IO a

liftSqlPersistMPool :: forall backend m a. (MonadIO m, BackendCompatible SqlBackend backend) => ReaderT backend (NoLoggingT (ResourceT IO)) a -> Pool backend -> m a

withSqlPool

Arguments

:: forall backend m a. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend)

=> (LogFunc -> IO backend)

create a new connection

-> Int

connection count

-> (Pool backend -> m a)

-> m a

withSqlPoolWithConfig

Arguments

:: forall backend m a. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend)

=> (LogFunc -> IO backend)

Function to create a new connection

-> ConnectionPoolConfig

-> (Pool backend -> m a)

-> m a

Creates a pool of connections to a SQL database which can be used by the Pool backend -> m a function. After the function completes, the connections are destroyed.

Since: persistent-2.11.0.0

createSqlPool :: forall backend m. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> Int -> m (Pool backend)

createSqlPoolWithConfig

Arguments

:: (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend)

=> (LogFunc -> IO backend)

Function to create a new connection

-> ConnectionPoolConfig

-> m (Pool backend)

Creates a pool of connections to a SQL database.

Since: persistent-2.11.0.0

withSqlConn :: forall backend m a. (MonadUnliftIO m, MonadLoggerIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> (backend -> m a) -> m a

Create a connection and run sql queries within it. This function automatically closes the connection on it's completion.

Example usage

{-# LANGUAGE GADTs #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeFamilies#-}
{-# LANGUAGE TemplateHaskell#-}
{-# LANGUAGE QuasiQuotes#-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}

import Control.Monad.IO.Class  (liftIO)
import Control.Monad.Logger
import Conduit
import Database.Persist
import Database.Sqlite
import Database.Persist.Sqlite
import Database.Persist.TH

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase|
Person
  name String
  age Int Maybe
  deriving Show
|]

openConnection :: LogFunc -> IO SqlBackend
openConnection logfn = do
 conn <- open "/home/sibi/test.db"
 wrapConnection conn logfn

main :: IO ()
main = do
  runNoLoggingT $ runResourceT $ withSqlConn openConnection (\backend ->
                                      flip runSqlConn backend $ do
                                        runMigration migrateAll
                                        insert_ $ Person "John doe" $ Just 35
                                        insert_ $ Person "Divya" $ Just 36
                                        (pers :: [Entity Person]) <- selectList [] []
                                        liftIO $ print pers
                                        return ()
                                     )

On executing it, you get this output:

Migrating: CREATE TABLE "person"("id" INTEGER PRIMARY KEY,"name" VARCHAR NOT NULL,"age" INTEGER NULL)
[Entity {entityKey = PersonKey {unPersonKey = SqlBackendKey {unSqlBackendKey = 1}}, entityVal = Person {personName = "John doe", personAge = Just 35}},Entity {entityKey = PersonKey {unPersonKey = SqlBackendKey {unSqlBackendKey = 2}}, entityVal = Person {personName = "Hema", personAge = Just 36}}]

withRawQuery :: forall (m :: Type -> Type) a. MonadIO m => Text -> [PersistValue] -> ConduitM [PersistValue] Void IO a -> ReaderT SqlBackend m a

toSqlKey :: ToBackendKey SqlBackend record => Int64 -> Key record

fromSqlKey :: ToBackendKey SqlBackend record => Key record -> Int64

getTableName :: forall record (m :: Type -> Type) backend. (PersistEntity record, BackendCompatible SqlBackend backend, Monad m) => record -> ReaderT backend m Text

get the SQL string for the table that a PersistEntity represents Useful for raw SQL queries

Your backend may provide a more convenient tableName function which does not operate in a Monad

tableDBName :: PersistEntity record => record -> EntityNameDB

useful for a backend to implement tableName by adding escaping

getFieldName :: forall record typ (m :: Type -> Type) backend. (PersistEntity record, PersistEntityBackend record ~ SqlBackend, BackendCompatible SqlBackend backend, Monad m) => EntityField record typ -> ReaderT backend m Text

get the SQL string for the field that an EntityField represents Useful for raw SQL queries

Your backend may provide a more convenient fieldName function which does not operate in a Monad

fieldDBName :: PersistEntity record => EntityField record typ -> FieldNameDB

useful for a backend to implement fieldName by adding escaping

filterClause

Arguments

:: PersistEntity val

=> Maybe FilterTablePrefix

include table name or EXCLUDED

-> SqlBackend

-> [Filter val]

-> Text

Render a [Filter record] into a Text value suitable for inclusion into a SQL query.

Since: persistent-2.12.1.0

filterClauseWithVals

Arguments

:: PersistEntity val

=> Maybe FilterTablePrefix

include table name or EXCLUDED

-> SqlBackend

-> [Filter val]

-> (Text, [PersistValue])

Render a [Filter record] into a Text value suitable for inclusion into a SQL query, as well as the [PersistValue] to properly fill in the ? place holders.

Since: persistent-2.12.1.0

orderClause

Arguments

:: PersistEntity val

=> Maybe FilterTablePrefix

include table name or EXCLUDED

-> SqlBackend

-> [SelectOpt val]

-> Text

Render a [SelectOpt record] made up *only* of Asc and Desc constructors into a Text value suitable for inclusion into a SQL query.

Since: persistent-2.13.2.0

decorateSQLWithLimitOffset :: Text -> (Int, Int) -> Text -> Text

Generates sql for limit and offset for postgres, sqlite and mysql.

parseMigration :: forall (m :: Type -> Type). (HasCallStack, MonadIO m) => Migration -> ReaderT SqlBackend m (Either [Text] CautiousMigration)

Given a Migration, this parses it and returns either a list of errors associated with the migration or a list of migrations to do.

parseMigration' :: forall (m :: Type -> Type). (HasCallStack, MonadIO m) => Migration -> ReaderT SqlBackend m CautiousMigration

Like parseMigration, but instead of returning the value in an Either value, it calls error on the error values.

printMigration :: forall (m :: Type -> Type). (HasCallStack, MonadIO m) => Migration -> ReaderT SqlBackend m ()

Prints a migration.

showMigration :: forall (m :: Type -> Type). (HasCallStack, MonadIO m) => Migration -> ReaderT SqlBackend m [Text]

Convert a Migration to a list of Text values corresponding to their Sql statements.

getMigration :: forall (m :: Type -> Type). (MonadIO m, HasCallStack) => Migration -> ReaderT SqlBackend m [Sql]

Return all of the Sql values associated with the given migration. Calls error if there's a parse error on any migration.

runMigration :: forall (m :: Type -> Type). MonadIO m => Migration -> ReaderT SqlBackend m ()

Runs a migration. If the migration fails to parse or if any of the migrations are unsafe, then this throws a PersistUnsafeMigrationException.

runMigrationQuiet :: forall (m :: Type -> Type). MonadIO m => Migration -> ReaderT SqlBackend m [Text]

Same as runMigration, but does not report the individual migrations on stderr. Instead it returns a list of the executed SQL commands.

This is a safer/more robust alternative to runMigrationSilent, but may be less silent for some persistent implementations, most notably persistent-postgresql

Since: persistent-2.10.2

runMigrationSilent :: forall (m :: Type -> Type). MonadUnliftIO m => Migration -> ReaderT SqlBackend m [Text]

Same as runMigration, but returns a list of the SQL commands executed instead of printing them to stderr.

This function silences the migration by remapping stderr. As a result, it is not thread-safe and can clobber output from other parts of the program. This implementation method was chosen to also silence postgresql migration output on stderr, but is not recommended!

runMigrationUnsafe :: forall (m :: Type -> Type). MonadIO m => Migration -> ReaderT SqlBackend m ()

Like runMigration, but this will perform the unsafe database migrations instead of erroring out.

runMigrationUnsafeQuiet :: forall (m :: Type -> Type). (HasCallStack, MonadIO m) => Migration -> ReaderT SqlBackend m [Text]

Same as runMigrationUnsafe, but returns a list of the SQL commands executed instead of printing them to stderr.

Since: persistent-2.10.2

reportErrors :: [Text] -> Migration

Report multiple errors in a Migration.

Since: persistent-2.9.2

addMigration

Arguments

:: Bool

Is the migration unsafe to run? (eg a destructive or non-idempotent update on the schema). If True, the migration is *unsafe*, and will need to be run manually later. If False, the migration is *safe*, and can be run any number of times.

-> Sql

A Text value representing the command to run on the database.

-> Migration

Add a migration to the migration plan.

Since: persistent-2.9.2

addMigrations :: CautiousMigration -> Migration

Add a CautiousMigration (aka a [(Bool, Text)]) to the migration plan.

Since: persistent-2.9.2

runSqlCommand :: SqlPersistT IO () -> Migration

Run an action against the database during a migration. Can be useful for eg creating Postgres extensions:

runSqlCommand $ rawExecute "CREATE EXTENSION IF NOT EXISTS "uuid-ossp";" []

Since: persistent-2.13.0.0

transactionSave :: forall (m :: Type -> Type). MonadIO m => ReaderT SqlBackend m ()

Commit the current transaction and begin a new one. This is used when a transaction commit is required within the context of runSqlConn (which brackets its provided action with a transaction begin/commit pair).

Since: persistent-1.2.0

transactionSaveWithIsolation :: forall (m :: Type -> Type). MonadIO m => IsolationLevel -> ReaderT SqlBackend m ()

Commit the current transaction and begin a new one with the specified isolation level.

Since: persistent-2.9.0

transactionUndo :: forall (m :: Type -> Type). MonadIO m => ReaderT SqlBackend m ()

Roll back the current transaction and begin a new one. This rolls back to the state of the last call to transactionSave or the enclosing runSqlConn call.

Since: persistent-1.2.0

transactionUndoWithIsolation :: forall (m :: Type -> Type). MonadIO m => IsolationLevel -> ReaderT SqlBackend m ()

Roll back the current transaction and begin a new one with the specified isolation level.

Since: persistent-2.9.0