-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | Type-safe EDSL for SQL queries on persistent backends.
--   
--   esqueleto is a bare bones, type-safe EDSL for SQL queries
--   that works with unmodified persistent SQL backends. Its
--   language closely resembles SQL, so you don't have to learn new
--   concepts, just new syntax, and it's fairly easy to predict the
--   generated SQL and optimize it for your backend. Most kinds of errors
--   committed when writing SQL are caught as compile-time
--   errors---although it is possible to write type-checked
--   esqueleto queries that fail at runtime.
--   
--   persistent is a library for type-safe data serialization. It
--   has many kinds of backends, such as SQL backends
--   (persistent-mysql, persistent-postgresql,
--   persistent-sqlite) and NoSQL backends
--   (persistent-mongoDB). While persistent is a nice
--   library for storing and retrieving records, including with filters, it
--   does not try to support some of the features that are specific to SQL
--   backends. In particular, esqueleto is the recommended library
--   for type-safe JOINs on persistent SQL backends. (The
--   alternative is using raw SQL, but that's error prone and does not
--   offer any composability.)
--   
--   Currently, SELECTs, UPDATEs, INSERTs and
--   DELETEs are supported. Not all SQL features are available,
--   but most of them can be easily added (especially functions), so please
--   open an issue or send a pull request if you need anything that is not
--   covered by esqueleto on
--   https://github.com/bitemyapp/esqueleto.
--   
--   The name of this library means "skeleton" in Portuguese and contains
--   all three SQL letters in the correct order =). It was inspired by
--   Scala's Squeryl but created from scratch.
@package esqueleto
@version 3.6.0.0

-- | This is an internal module. This module may have breaking changes
--   without a corresponding major version bump. If you use this module,
--   please open an issue with your use-case so we can safely support it.
module Database.Esqueleto.Internal.ExprParser

-- | A type representing the access of a table value. In Esqueleto, we get
--   a guarantee that the access will look something like:
--   
--   
--   escape-char [character] escape-char . escape-char [character] escape-char
--               ^^^^^^^^^^^                           ^^^^^^^^^^^
--               table name                            column name
--   
data TableAccess
TableAccess :: Text -> Text -> TableAccess
[tableAccessTable] :: TableAccess -> Text
[tableAccessColumn] :: TableAccess -> Text

-- | Parse a SqlExpr (Value Bool)'s textual representation into a
--   list of TableAccess
parseOnExpr :: SqlBackend -> Text -> Either String (Set TableAccess)

-- | This function uses the connEscapeName function in the
--   SqlBackend with an empty identifier to pull out an escape
--   character. This implementation works with postgresql, mysql, and
--   sqlite backends.
mkEscapeChar :: SqlBackend -> Either String Char
type ExprParser a = Char -> Parser a
onExpr :: ExprParser (Set TableAccess)
skipToEscape :: ExprParser ()
parseEscapedIdentifier :: ExprParser [Char]
parseTableAccess :: ExprParser TableAccess
parseEscapedChars :: ExprParser [Char]
instance GHC.Classes.Eq Database.Esqueleto.Internal.ExprParser.TableAccess
instance GHC.Classes.Ord Database.Esqueleto.Internal.ExprParser.TableAccess
instance GHC.Internal.Show.Show Database.Esqueleto.Internal.ExprParser.TableAccess

-- | This is an internal module, anything exported by this module may
--   change without a major version bump. Please use only
--   Database.Esqueleto if possible.
--   
--   If you use this module, please report what your use case is on the
--   issue tracker so we can safely support it.
module Database.Esqueleto.Internal.Internal

-- | (Internal) Start a from query with an entity. from does
--   two kinds of magic using fromStart, fromJoin and
--   fromFinish:
--   
--   
--   
- The simple but tedious magic of allowing tuples to be used.
--   
- The more advanced magic of creating JOINs. The
--   JOIN is processed from right to left. The rightmost entity of
--   the JOIN is created with fromStart. Each JOIN
--   step is then translated into a call to fromJoin. In the end,
--   fromFinish is called to materialize the JOIN.
--   
fromStart :: (PersistEntity a, BackendCompatible SqlBackend (PersistEntityBackend a)) => SqlQuery (PreprocessedFrom (SqlExpr (Entity a)))

-- | Copied from persistent
newtype DBName
DBName :: Text -> DBName
[unDBName] :: DBName -> Text

-- | (Internal) Same as fromStart, but entity may be missing.
fromStartMaybe :: (PersistEntity a, BackendCompatible SqlBackend (PersistEntityBackend a)) => SqlQuery (PreprocessedFrom (SqlExpr (Maybe (Entity a))))

-- | (Internal) Do a JOIN.
fromJoin :: IsJoinKind join => PreprocessedFrom a -> PreprocessedFrom b -> SqlQuery (PreprocessedFrom (join a b))

-- | (Internal) Finish a JOIN.
fromFinish :: PreprocessedFrom a -> SqlQuery a

-- | WHERE clause: restrict the query's result.
where_ :: 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 `<a>InnerJoin</a>` 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 `<tt>CrossJoin</tt>` 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 `<a>InnerJoin</a>` bar `<a>InnerJoin</a>` 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 `<a>InnerJoin</a>` bar `<a>InnerJoin</a>` baz) -> do
--     on (foo ^. FooId ==. bar ^. BarFooId)
--     on (baz ^. BazId ==. bar ^. BarBazId)
--     ...
--   
on :: SqlExpr (Value Bool) -> SqlQuery ()

-- | GROUP BY clause. You can enclose multiple columns in a tuple.
--   
--   
--   select $ from \(foo `<tt>InnerJoin</tt>` 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 `<tt>InnerJoin</tt>` 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)
--   
groupBy :: ToSomeValues a => a -> SqlQuery ()

-- | An alias for groupBy that avoids conflict with the term from
--   Data.List groupBy.
groupBy_ :: ToSomeValues a => a -> SqlQuery ()

-- | ORDER BY clause. See also asc and desc.
--   
--   Multiple calls to orderBy get concatenated on the final query,
--   including distinctOnOrderBy.
orderBy :: [SqlExpr OrderBy] -> SqlQuery ()

-- | Ascending order of this field or SqlExpression.
asc :: PersistField a => SqlExpr (Value a) -> SqlExpr OrderBy

-- | Descending order of this field or SqlExpression.
desc :: PersistField a => SqlExpr (Value a) -> SqlExpr OrderBy
orderByExpr :: Builder -> SqlExpr (Value a) -> SqlExpr OrderBy

-- | LIMIT. Limit the number of returned rows.
limit :: Int64 -> SqlQuery ()

-- | OFFSET. Usually used with limit.
offset :: Int64 -> SqlQuery ()

-- | 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 ())
--     ...
--   
distinct :: 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.

-- | Deprecated: This function is deprecated, as it is only supported in
--   Postgresql. Please use the variant in PostgreSQL instead.
distinctOn :: [SqlExpr DistinctOn] -> SqlQuery a -> SqlQuery a

-- | Erase an SqlExpression's type so that it's suitable to be used by
--   distinctOn.
don :: SqlExpr (Value a) -> SqlExpr DistinctOn

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

-- | Deprecated: This function is deprecated, as it is only supported in
--   Postgresql. Please use the function defined in PostgreSQL
--   instead.
distinctOnOrderBy :: [SqlExpr OrderBy] -> SqlQuery a -> SqlQuery a

-- | HAVING.
having :: SqlExpr (Value Bool) -> 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.
locking :: LockingKind -> SqlQuery ()

-- | Helper to add a any type of locking clause to a query
putLocking :: LockingClause -> SqlQuery ()

-- | 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.
subSelect :: (PersistField a, NullableFieldProjection a a') => SqlQuery (SqlExpr (Value 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).
subSelectMaybe :: PersistField a => SqlQuery (SqlExpr (Value (Maybe a))) -> SqlExpr (Value (Maybe 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.
subSelectCount :: (Num a, PersistField a) => SqlQuery ignored -> SqlExpr (Value 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.
subSelectList :: PersistField a => SqlQuery (SqlExpr (Value a)) -> SqlExpr (ValueList 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)
--   
subSelectForeign :: (BackendCompatible SqlBackend (PersistEntityBackend val1), PersistEntity val1, PersistEntity val2, PersistField a) => SqlExpr (Entity val2) -> EntityField val2 (Key val1) -> (SqlExpr (Entity val1) -> 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:
--   
--   
--   
- 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.
--   
- 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.
subSelectUnsafe :: PersistField a => SqlQuery (SqlExpr (Value a)) -> SqlExpr (Value a)

-- | Project a field of an entity.
(^.) :: forall typ val. (PersistEntity val, PersistField typ) => SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
infixl 9 ^.

-- | Project an SqlExpression that may be null, guarding against null
--   cases.
withNonNull :: PersistField typ => SqlExpr (Value (Maybe typ)) -> (SqlExpr (Value typ) -> SqlQuery a) -> SqlQuery a

-- | Project an EntityField of a nullable entity. The result type
--   will be Nullable, meaning that nested Maybe won't be
--   produced here.
--   
--   As of v3.6.0.0, this will attempt to combine nested Maybe. If
--   you want to keep nested Maybe, then see ??..
(?.) :: (PersistEntity val, PersistField typ) => SqlExpr (Maybe (Entity val)) -> EntityField val typ -> SqlExpr (Value (Maybe (Nullable typ)))
infixl 9 ?.

-- | Project a field of an entity that may be null.
--   
--   This variant will produce a nested Maybe if you select a
--   Maybe column. If you want to collapse Maybe, see
--   ?..
(??.) :: (PersistEntity val, PersistField typ) => SqlExpr (Maybe (Entity val)) -> EntityField val typ -> SqlExpr (Value (Maybe typ))

-- | Lift a constant value from Haskell-land to the query.
val :: PersistField typ => typ -> SqlExpr (Value typ)

-- | 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:
--   
--   TODO: table
--   
--   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}
--   
isNothing :: PersistField typ => SqlExpr (Value (Maybe typ)) -> SqlExpr (Value Bool)

-- | An alias for isNothing that avoids clashing with the function
--   from Data.Maybe isNothing.
isNothing_ :: PersistField typ => SqlExpr (Value (Maybe typ)) -> SqlExpr (Value Bool)

-- | Analogous to Just, promotes a value of type typ into
--   one of type Maybe typ. It should hold that val .
--   Just === just . val.
--   
--   This function will try not to produce a nested Maybe. This is
--   in accord with how SQL represents NULL. That means that
--   just . just = just. This behavior was
--   changed in v3.6.0.0. If you want to produce nested Maybe, see
--   just'.
just :: NullableFieldProjection typ typ' => SqlExpr (Value typ) -> SqlExpr (Value (Maybe typ'))

-- | Like just, but this function does not try to collapse nested
--   Maybe. This may be useful if you have type inference problems
--   with just.
just' :: SqlExpr (Value typ) -> SqlExpr (Value (Maybe typ))

-- | NULL value.
nothing :: SqlExpr (Value (Maybe typ))

-- | Join nested Maybes in a Value into one. This is useful
--   when calling aggregate functions on nullable fields.
--   
--   As of v3.6.0.0, this function will attempt to work on both
--   SqlExpr (Value (Maybe a)) as well as
--   SqlExpr (Value (Maybe (Maybe a)))
--   inputs to make transitioning to NullableFieldProjection easier.
--   This may make type inference worse in some cases. If you want the
--   monomorphic variant, see joinV'
joinV :: NullableFieldProjection typ typ' => SqlExpr (Value (Maybe typ)) -> SqlExpr (Value (Maybe typ'))

-- | Like joinV, but monomorphic: the input type only works on
--   SqlExpr (Value (Maybe (Maybe a))).
--   
--   This function may be useful if you have type inference issues with
--   joinV.
joinV' :: SqlExpr (Value (Maybe (Maybe typ))) -> SqlExpr (Value (Maybe typ))
countHelper :: Num a => Builder -> Builder -> SqlExpr (Value typ) -> SqlExpr (Value a)

-- | COUNT(*) value.
countRows :: Num a => SqlExpr (Value a)

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

-- | COUNT(DISTINCT x).
countDistinct :: Num a => SqlExpr (Value typ) -> SqlExpr (Value a)
not_ :: SqlExpr (Value Bool) -> SqlExpr (Value Bool)

-- | This operator produces the SQL operator =, which is used to
--   compare values for equality.
--   
--   Example:
--   
--   
--   query :: UserId -> SqlPersistT IO [Entity User]
--   query userId = select $ do
--       user <- from $ table @User
--       where_ (user ^. UserId ==. val userId)
--       pure user
--   
--   
--   This would generate the following SQL:
--   
--   
--   SELECT user.*
--   FROM user
--   WHERE user.id = ?
--   
(==.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 ==.

-- | This operator translates to the SQL operator >=.
--   
--   Example:
--   
--   
--   where_ $ user ^. UserAge >=. val 21
--   
(>=.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 >=.

-- | This operator translates to the SQL operator >.
--   
--   Example:
--   
--   
--   where_ $ user ^. UserAge >. val 20
--   
(>.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 >.

-- | This operator translates to the SQL operator <=.
--   
--   Example:
--   
--   
--   where_ $ val 21 <=. user ^. UserAge
--   
(<=.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 <=.

-- | This operator translates to the SQL operator <.
--   
--   Example:
--   
--   
--   where_ $ val 20 <. user ^. UserAge
--   
(<.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 <.

-- | This operator translates to the SQL operator !=.
--   
--   Example:
--   
--   
--   where_ $ user ^. UserName !=. val Bob
--   
(!=.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 !=.

-- | This operator translates to the SQL operator AND.
--   
--   Example:
--   
--   
--   where_ $
--           user ^. UserName ==. val Matt
--       &&. user ^. UserAge >=. val 21
--   
(&&.) :: SqlExpr (Value Bool) -> SqlExpr (Value Bool) -> SqlExpr (Value Bool)
infixr 3 &&.

-- | This operator translates to the SQL operator AND.
--   
--   Example:
--   
--   
--   where_ $
--           user ^. UserName ==. val Matt
--       ||. user ^. UserName ==. val John
--   
(||.) :: SqlExpr (Value Bool) -> SqlExpr (Value Bool) -> SqlExpr (Value Bool)
infixr 2 ||.

-- | This operator translates to the SQL operator +.
--   
--   This does not require or assume anything about the SQL values.
--   Interpreting what +. means for a given type is left to the
--   database engine.
--   
--   Example:
--   
--   
--   user ^. UserAge +. val 10
--   
(+.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)
infixl 6 +.

-- | This operator translates to the SQL operator -.
--   
--   This does not require or assume anything about the SQL values.
--   Interpreting what -. means for a given type is left to the
--   database engine.
--   
--   Example:
--   
--   
--   user ^. UserAge -. val 10
--   
(-.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)
infixl 6 -.

-- | This operator translates to the SQL operator /.
--   
--   This does not require or assume anything about the SQL values.
--   Interpreting what /. means for a given type is left to the
--   database engine.
--   
--   Example:
--   
--   
--   user ^. UserAge /. val 10
--   
(/.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)
infixl 7 /.

-- | This operator translates to the SQL operator *.
--   
--   This does not require or assume anything about the SQL values.
--   Interpreting what *. means for a given type is left to the
--   database engine.
--   
--   Example:
--   
--   
--   user ^. UserAge *. val 10
--   
(*.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)
infixl 7 *.

-- | a between (b, c) translates to the SQL expression
--   a >= b AND a <= c. It does not use a SQL
--   BETWEEN operator.
--   
--   @since: 3.1.0
between :: PersistField a => SqlExpr (Value a) -> (SqlExpr (Value a), SqlExpr (Value a)) -> SqlExpr (Value Bool)
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)
sum_ :: (PersistField a, PersistField b) => SqlExpr (Value a) -> SqlExpr (Value (Maybe b))
min_ :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value (Maybe (Nullable a)))
max_ :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value (Maybe (Nullable a)))
avg_ :: (PersistField a, PersistField b) => SqlExpr (Value a) -> SqlExpr (Value (Maybe 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.
castNum :: (Num a, Num b) => SqlExpr (Value a) -> SqlExpr (Value b)

-- | Same as castNum, but for nullable values.
castNumM :: (Num a, Num b) => SqlExpr (Value (Maybe a)) -> SqlExpr (Value (Maybe b))

-- | 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.
coalesce :: (PersistField a, NullableFieldProjection a a') => [SqlExpr (Value (Maybe a))] -> SqlExpr (Value (Maybe a'))

-- | Like coalesce, but takes a non-nullable SqlExpression placed
--   at the end of the SqlExpression list, which guarantees a non-NULL
--   result.
coalesceDefault :: PersistField a => [SqlExpr (Value (Maybe a))] -> SqlExpr (Value a) -> SqlExpr (Value a)

-- | LOWER function.
lower_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | UPPER function. @since 3.3.0
upper_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | TRIM function. @since 3.3.0
trim_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | RTRIM function. @since 3.3.0
rtrim_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | LTRIM function. @since 3.3.0
ltrim_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | LENGTH function. @since 3.3.0
length_ :: (SqlString s, Num a) => SqlExpr (Value s) -> SqlExpr (Value a)

-- | LEFT function. @since 3.3.0
left_ :: (SqlString s, Num a) => (SqlExpr (Value s), SqlExpr (Value a)) -> SqlExpr (Value s)

-- | RIGHT function. @since 3.3.0
right_ :: (SqlString s, Num a) => (SqlExpr (Value s), SqlExpr (Value a)) -> SqlExpr (Value s)

-- | LIKE operator.
like :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s) -> SqlExpr (Value Bool)
infixr 2 `like`

-- | ILIKE operator (case-insensitive LIKE).
--   
--   Supported by PostgreSQL only. Deprecated in version 3.6.0 in favor of
--   the version available from Database.Esqueleto.PostgreSQL.

-- | Deprecated: Since 3.6.0: ilike is only supported on
--   Postgres. Please import it from 'Database.Esqueleto.PostgreSQL.
ilike :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s) -> SqlExpr (Value Bool)
infixr 2 `ilike`

-- | 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 `<a>like</a>` (%) ++. val "John" ++. (%)
--   
(%) :: SqlString s => SqlExpr (Value s)

-- | The CONCAT function with a variable number of parameters.
--   Supported by MySQL and PostgreSQL. SQLite supports this in versions
--   after 3.44.0, and persistent-sqlite supports this in versions
--   2.13.3.0 and after.
concat_ :: SqlString s => [SqlExpr (Value s)] -> SqlExpr (Value s)

-- | The || string concatenation operator (named after Haskell's
--   ++ in order to avoid naming clash with ||.).
--   
--   Supported by SQLite and PostgreSQL.
--   
--   MySQL support requires setting the SQL mode to
--   PIPES_AS_CONCAT or ANSI - see this StackOverflow
--   answer.
(++.) :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s) -> SqlExpr (Value s)
infixr 5 ++.

-- | 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.
castString :: (SqlString s, SqlString r) => SqlExpr (Value s) -> SqlExpr (Value r)

-- | Execute a subquery SELECT in an SqlExpression. Returns a list
--   of values.
subList_select :: PersistField a => SqlQuery (SqlExpr (Value a)) -> SqlExpr (ValueList a)

-- | Lift a list of constant value from Haskell-land to the query.
valList :: PersistField typ => [typ] -> SqlExpr (ValueList 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.
justList :: SqlExpr (ValueList typ) -> SqlExpr (ValueList (Maybe typ))

-- | 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 `<tt>in_</tt>` valList personIds
--   return person
--   
--   
--   Where personIds is of type [Key Person].
in_ :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (ValueList typ) -> SqlExpr (Value Bool)

-- | NOT IN operator.
notIn :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (ValueList typ) -> SqlExpr (Value Bool)

-- | EXISTS operator. For example:
--   
--   
--   select $
--   from $ \person -> do
--   where_ $ exists $
--            from $ \post -> do
--            where_ (post ^. BlogPostAuthorId ==. person ^. PersonId)
--   return person
--   
exists :: SqlQuery () -> SqlExpr (Value Bool)

-- | NOT EXISTS operator.
notExists :: SqlQuery () -> SqlExpr (Value Bool)

-- | 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.
set :: PersistEntity val => SqlExpr (Entity val) -> [SqlExpr (Entity val) -> SqlExpr Update] -> SqlQuery ()
(=.) :: (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 /=.

-- | Apply a PersistField constructor to SqlExpr Value
--   arguments.
(<#) :: (a -> b) -> SqlExpr (Value a) -> SqlExpr (Insertion b)

-- | Apply extra SqlExpr Value arguments to a PersistField
--   constructor
(<&>) :: SqlExpr (Insertion (a -> b)) -> SqlExpr (Value a) -> SqlExpr (Insertion b)

-- | CASE statement. For example:
--   
--   
--   select $
--   return $
--   case_
--      [ when_
--          (exists $
--          from $ \p -> do
--          where_ (p ^. PersonName ==. val "Mike"))
--        then_
--          (subSelect $
--          from $ \v -> do
--          let sub =
--                  from $ \c -> do
--                  where_ (c ^. PersonName ==. val "Mike")
--                  return (c ^. PersonFavNum)
--          where_ (just (v ^. PersonFavNum) >. subSelect 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.
--   
case_ :: PersistField a => [(SqlExpr (Value Bool), SqlExpr (Value a))] -> SqlExpr (Value a) -> SqlExpr (Value a)

-- | 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 `<tt>InnerJoin</tt>` 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.
toBaseId :: ToBaseId ent => SqlExpr (Value (Key ent)) -> SqlExpr (Value (Key (BaseEnt ent)))

-- | Like toBaseId, but works on Maybe keys.
toBaseIdMaybe :: ToBaseId ent => SqlExpr (Value (Maybe (Key ent))) -> SqlExpr (Value (Maybe (Key (BaseEnt ent))))

-- | The inverse of toBaseId. Note that this is somewhat less "safe"
--   than toBaseId. Calling toBaseId will usually mean that a
--   foreign key constraint is present that guarantees the presence of the
--   base ID. fromBaseId has no such guarantee. Consider the code
--   example given in toBaseId:
--   
--   
--   Bar
--     barNum Int
--   Foo
--     bar BarId
--     fooNum Int
--     Primary bar
--   
--   
--   
--   instance ToBaseId Foo where
--     type BaseEnt Foo = Bar
--     toBaseIdWitness barId = FooKey barId
--   
--   
--   The type of toBaseId for Foo would be:
--   
--   
--   toBaseId :: SqlExpr (Value FooId) -> SqlExpr (Value BarId)
--   
--   
--   The foreign key constraint on Foo means that every
--   FooId points to a BarId in the database. However,
--   fromBaseId will not have this:
--   
--   
--   fromBaseId :: SqlExpr (Value BarId) -> SqlExpr (Value FooId)
--   
fromBaseId :: ToBaseId ent => SqlExpr (Value (Key (BaseEnt ent))) -> SqlExpr (Value (Key ent))

-- | As fromBaseId, but works on Maybe keys.
fromBaseIdMaybe :: ToBaseId ent => SqlExpr (Value (Maybe (Key (BaseEnt ent)))) -> SqlExpr (Value (Maybe (Key ent)))

-- | Syntax sugar for case_.
when_ :: expr (Value Bool) -> () -> expr a -> (expr (Value Bool), expr a)

-- | Syntax sugar for case_.
then_ :: ()

-- | Syntax sugar for case_.
else_ :: expr a -> expr a

-- | A single value (as opposed to a whole entity). You may use
--   (^.) or (?.) to get a Value
--   from an Entity.
newtype Value a
Value :: a -> Value a
[unValue] :: Value a -> 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).
newtype ValueList a
ValueList :: a -> ValueList a

-- | A wrapper type for for any expr (Value a) for all a.
data SomeValue
[SomeValue] :: forall a. SqlExpr (Value a) -> SomeValue

-- | A class of things that can be converted into a list of SomeValue. It
--   has instances for tuples and is the reason why groupBy can take
--   tuples, like groupBy (foo ^. FooId, foo ^.
--   FooName, foo ^. FooType).
class ToSomeValues a
toSomeValues :: ToSomeValues a => a -> [SomeValue]
type family KnowResult a

-- | A class for constructors or function which result type is known.
class FinalResult a
finalR :: FinalResult a => a -> KnowResult a

-- | Convert a constructor for a Unique key on a record to the
--   UniqueDef that defines it. You can supply just the constructor
--   itself, or a value of the type - the library is capable of figuring it
--   out from there.
toUniqueDef :: (KnowResult a ~ Unique val, PersistEntity val, FinalResult a) => a -> UniqueDef

-- | Render updates to be use in a SET clause for a given sql backend.
renderUpdates :: BackendCompatible SqlBackend backend => backend -> [SqlExpr (Entity val) -> SqlExpr Update] -> (Builder, [PersistValue])

-- | Data type that represents an INNER JOIN (see
--   LeftOuterJoin for an example).
data InnerJoin a b
InnerJoin :: a -> b -> InnerJoin a b
infixl 2 `InnerJoin`
infixl 2 `InnerJoin`

-- | Data type that represents a CROSS JOIN (see
--   LeftOuterJoin for an example).
data CrossJoin a b
CrossJoin :: a -> b -> CrossJoin a b
infixl 2 `CrossJoin`
infixl 2 `CrossJoin`

-- | Data type that represents a LEFT OUTER JOIN. For example,
--   
--   
--   select $
--   from $ \(person `<tt>LeftOuterJoin</tt>` pet) ->
--     ...
--   
--   
--   is translated into
--   
--   
--   SELECT ...
--   FROM Person LEFT OUTER JOIN Pet
--   ...
--   
--   
--   See also: from.
data LeftOuterJoin a b
LeftOuterJoin :: a -> b -> LeftOuterJoin a b
infixl 2 `LeftOuterJoin`
infixl 2 `LeftOuterJoin`

-- | Data type that represents a RIGHT OUTER JOIN (see
--   LeftOuterJoin for an example).
data RightOuterJoin a b
RightOuterJoin :: a -> b -> RightOuterJoin a b
infixl 2 `RightOuterJoin`
infixl 2 `RightOuterJoin`

-- | Data type that represents a FULL OUTER JOIN (see
--   LeftOuterJoin for an example).
data FullOuterJoin a b
FullOuterJoin :: a -> b -> FullOuterJoin a b
infixl 2 `FullOuterJoin`
infixl 2 `FullOuterJoin`

-- | (Internal) A kind of JOIN.
data JoinKind

-- | 
--   INNER JOIN
--   
InnerJoinKind :: JoinKind

-- | 
--   CROSS JOIN
--   
CrossJoinKind :: JoinKind

-- | 
--   LEFT OUTER JOIN
--   
LeftOuterJoinKind :: JoinKind

-- | 
--   RIGHT OUTER JOIN
--   
RightOuterJoinKind :: JoinKind

-- | 
--   FULL OUTER JOIN
--   
FullOuterJoinKind :: JoinKind

-- | (Internal) Functions that operate on types (that should be) of kind
--   JoinKind.
class IsJoinKind (join :: Type -> Type -> Type)

-- | (Internal) smartJoin a b is a JOIN of the correct
--   kind.
smartJoin :: IsJoinKind join => a -> b -> join a b

-- | (Internal) Reify a JoinKind from a JOIN. This
--   function is non-strict.
reifyJoinKind :: IsJoinKind join => join a b -> JoinKind

-- | Exception thrown whenever on is used to create an ON
--   clause but no matching JOIN is found.
data OnClauseWithoutMatchingJoinException
OnClauseWithoutMatchingJoinException :: String -> OnClauseWithoutMatchingJoinException

-- | Phantom type used by orderBy, asc and desc.
data OrderBy

-- | Phantom type used by distinctOn and don.
data DistinctOn

-- | Phantom type for a SET operation on an entity of the given
--   type (see set and (=.)).
data Update

-- | Phantom type used by insertSelect.
data Insertion a

-- | A left-precedence pair. Pronounced "and". Used to represent
--   expressions that have been joined together.
--   
--   The precedence behavior can be demonstrated by:
--   
--   
--   a :& b :& c == ((a :& b) :& c)
--   
--   
--   See the examples at the beginning of this module to see how this
--   operator is used in JOIN operations.
data a :& b
(:&) :: a -> b -> (:&) a b
infixl 2 :&
infixl 2 :&

-- | 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.
data LockingKind

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

-- | Deprecated: The constructors for LockingKind are deprecated
--   in v3.6.0.0. Instead, please refer to the smart constructors
--   forUpdate and forUpdateSkipLocked.
ForUpdate :: LockingKind

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

-- | Deprecated: The constructors for LockingKind are deprecated
--   in v3.6.0.0. Instead, please refer to the smart constructors
--   forUpdate and forUpdateSkipLocked.
ForUpdateSkipLocked :: LockingKind

-- | FOR SHARE syntax. Supported by PostgreSQL.

-- | Deprecated: The constructors for LockingKind are deprecated
--   in v3.6.0.0. Instead, please refer to the smart constructor
--   forShare exported from Database.Esqueleto.PostgreSQL.
ForShare :: LockingKind

-- | LOCK IN SHARE MODE syntax. Supported by MySQL.

-- | Deprecated: The constructors for LockingKind are deprecated
--   in v3.6.0.0. Instead, please refer to the smart constructors
--   lockInShareMode exported from Database.Esqueleto.MySQL.
LockInShareMode :: LockingKind

-- | FOR UPDATE syntax.
--   
--   Usage:
--   
--   
--   locking forUpdate
--   
forUpdate :: LockingKind

-- | FOR UPDATE SKIP LOCKED syntax.
--   
--   
--   locking forUpdateSkipLocked
--   
forUpdateSkipLocked :: LockingKind

-- | Postgres specific locking, used only internally
data PostgresLockingKind
PostgresLockingKind :: PostgresRowLevelLockStrength -> Maybe LockingOfClause -> OnLockedBehavior -> PostgresLockingKind
[postgresRowLevelLockStrength] :: PostgresLockingKind -> PostgresRowLevelLockStrength
[postgresLockingOfClause] :: PostgresLockingKind -> Maybe LockingOfClause
[postgresOnLockedBehavior] :: PostgresLockingKind -> OnLockedBehavior
data PostgresRowLevelLockStrength
PostgresForUpdate :: PostgresRowLevelLockStrength
PostgresForNoKeyUpdate :: PostgresRowLevelLockStrength
PostgresForShare :: PostgresRowLevelLockStrength
PostgresForKeyShare :: PostgresRowLevelLockStrength
data LockingOfClause
[LockingOfClause] :: forall a. LockableEntity a => a -> LockingOfClause
data OnLockedBehavior

-- | NOWAIT syntax locking behaviour. query excutes immediately
--   failing on locked rows
NoWait :: OnLockedBehavior

-- | SKIP LOCKED syntax locking behaviour. query skips locked rows
SkipLocked :: OnLockedBehavior

-- | default locking behaviour. query will wait on locked rows
Wait :: OnLockedBehavior

-- | 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
--   
class LockableEntity a
flattenLockableEntity :: LockableEntity a => a -> NonEmpty LockableSqlExpr
makeLockableEntity :: LockableEntity a => IdentInfo -> a -> (Builder, [PersistValue])
data LockableSqlExpr
[LockableSqlExpr] :: forall val. PersistEntity val => SqlExpr (Entity val) -> LockableSqlExpr

-- | 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.
class PersistField a => SqlString a

-- | Class that enables one to use toBaseId to convert an entity's
--   key on a query into another (cf. toBaseId).
class ToBaseId ent where {
    
    -- | e.g. <tt>type BaseEnt MyBase = MyChild</tt>
    type BaseEnt 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.
toBaseIdWitness :: ToBaseId ent => Key (BaseEnt ent) -> Key ent

-- | 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 `<a>LeftOuterJoin</a>` mb) -> ...
--   from $ \(p1 `<a>InnerJoin</a>` f `<a>InnerJoin</a>` p2) -> ...
--   from $ \((p1 `<a>InnerJoin</a>` f) `<a>InnerJoin</a>` 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 `<a>LeftOuterJoin</a>` mb)
--     :: (...) => InnerJoin (expr (Entity Person)) (expr (Maybe (Entity BlogPost)))
--   (p1 `<a>InnerJoin</a>` f `<a>InnerJoin</a>` p2)
--     :: (...) => InnerJoin
--                   (InnerJoin (expr (Entity Person))
--                              (expr (Entity Follow)))
--                   (expr (Entity Person))
--   (p1 `<a>InnerJoin</a>` (f `<a>InnerJoin</a>` p2)) ::
--     :: (...) => InnerJoin
--                   (expr (Entity Person))
--                   (InnerJoin (expr (Entity Follow))
--                              (expr (Entity Person)))
--   
--   
--   Note that some backends may not support all kinds of JOINs.
from :: From a => (a -> SqlQuery b) -> SqlQuery b

-- | (Internal) Class that implements the tuple from magic (see
--   fromStart).
class From a
from_ :: From a => SqlQuery a

-- | (Internal) Class that implements the JOIN from magic
--   (see fromStart).
class FromPreprocess a
fromPreprocess :: FromPreprocess a => SqlQuery (PreprocessedFrom a)

-- | Exception data type for esqueleto internal errors
data EsqueletoError
CompositeKeyErr :: CompositeKeyError -> EsqueletoError
AliasedValueErr :: UnexpectedValueError -> EsqueletoError
UnexpectedCaseErr :: UnexpectedCaseError -> EsqueletoError
SqlBinOpCompositeErr :: SqlBinOpCompositeError -> EsqueletoError
data UnexpectedValueError
NotError :: UnexpectedValueError
ToInsertionError :: UnexpectedValueError
CombineInsertionError :: UnexpectedValueError
FoldHelpError :: UnexpectedValueError
SqlCaseError :: UnexpectedValueError
SqlCastAsError :: UnexpectedValueError
SqlFunctionError :: UnexpectedValueError
MakeOnClauseError :: UnexpectedValueError
MakeExcError :: UnexpectedValueError
MakeSetError :: UnexpectedValueError
MakeWhereError :: UnexpectedValueError
MakeHavingError :: UnexpectedValueError
FilterWhereAggError :: UnexpectedValueError
FilterWhereClauseError :: UnexpectedValueError
type CompositeKeyError = UnexpectedValueError
data UnexpectedCaseError
EmptySqlExprValueList :: UnexpectedCaseError
MakeFromError :: UnexpectedCaseError
UnsupportedSqlInsertIntoType :: UnexpectedCaseError
InsertionFinalError :: UnexpectedCaseError
NewIdentForError :: UnexpectedCaseError
UnsafeSqlCaseError :: UnexpectedCaseError
OperationNotSupported :: UnexpectedCaseError
NotImplemented :: UnexpectedCaseError
data SqlBinOpCompositeError
MismatchingLengthsError :: SqlBinOpCompositeError
NullPlaceholdersError :: SqlBinOpCompositeError
DeconstructionError :: SqlBinOpCompositeError

-- | SQL backend for esqueleto using SqlPersistT.
newtype SqlQuery a
Q :: WriterT SideData (State IdentState) a -> SqlQuery a
[unQ] :: SqlQuery a -> WriterT SideData (State IdentState) a

-- | Constraint synonym for persistent entities whose backend is
--   SqlBackend.
type SqlEntity ent = (PersistEntity ent, PersistEntityBackend ent ~ SqlBackend)

-- | Side data written by SqlQuery.
data SideData
SideData :: !DistinctClause -> ![FromClause] -> ![SetClause] -> !WhereClause -> !GroupByClause -> !HavingClause -> ![OrderByClause] -> !LimitClause -> !LockingClause -> ![CommonTableExpressionClause] -> SideData
[sdDistinctClause] :: SideData -> !DistinctClause
[sdFromClause] :: SideData -> ![FromClause]
[sdSetClause] :: SideData -> ![SetClause]
[sdWhereClause] :: SideData -> !WhereClause
[sdGroupByClause] :: SideData -> !GroupByClause
[sdHavingClause] :: SideData -> !HavingClause
[sdOrderByClause] :: SideData -> ![OrderByClause]
[sdLimitClause] :: SideData -> !LimitClause
[sdLockingClause] :: SideData -> !LockingClause
[sdCteClause] :: SideData -> ![CommonTableExpressionClause]

-- | The DISTINCT "clause".
data DistinctClause

-- | The default, everything.
DistinctAll :: DistinctClause

-- | Only DISTINCT, SQL standard.
DistinctStandard :: DistinctClause

-- | DISTINCT ON, PostgreSQL extension.
DistinctOn :: [SqlExpr DistinctOn] -> DistinctClause

-- | A part of a FROM clause.
data FromClause
FromStart :: Ident -> EntityDef -> FromClause
FromJoin :: FromClause -> JoinKind -> FromClause -> Maybe (SqlExpr (Value Bool)) -> FromClause
OnClause :: SqlExpr (Value Bool) -> FromClause
FromRaw :: (NeedParens -> IdentInfo -> (Builder, [PersistValue])) -> FromClause
data CommonTableExpressionKind
RecursiveCommonTableExpression :: CommonTableExpressionKind
NormalCommonTableExpression :: CommonTableExpressionKind
type CommonTableExpressionModifierAfterAs = CommonTableExpressionClause -> IdentInfo -> Builder
data CommonTableExpressionClause
CommonTableExpressionClause :: CommonTableExpressionKind -> CommonTableExpressionModifierAfterAs -> Ident -> (IdentInfo -> (Builder, [PersistValue])) -> CommonTableExpressionClause
data SubQueryType
NormalSubQuery :: SubQueryType
LateralSubQuery :: SubQueryType
collectIdents :: FromClause -> Set Ident

-- | A part of a SET clause.
newtype SetClause
SetClause :: SqlExpr Update -> SetClause

-- | Collect OnClauses on FromJoins. Returns the first
--   unmatched OnClauses data on error. Returns a list without
--   OnClauses on success.
collectOnClauses :: SqlBackend -> [FromClause] -> Either (SqlExpr (Value Bool)) [FromClause]

-- | A complete WHERE clause.
data WhereClause
Where :: SqlExpr (Value Bool) -> WhereClause
NoWhere :: WhereClause

-- | A GROUP BY clause.
newtype GroupByClause
GroupBy :: [SomeValue] -> GroupByClause

-- | A HAVING cause.
type HavingClause = WhereClause

-- | A ORDER BY clause.
type OrderByClause = SqlExpr OrderBy

-- | A LIMIT clause.
data LimitClause
Limit :: Maybe Int64 -> Maybe Int64 -> LimitClause

-- | A locking clause.
data LockingClause

-- | Locking clause not specific to any database implementation
LegacyLockingClause :: LockingKind -> LockingClause

-- | Locking clause specific to postgres
PostgresLockingClauses :: [PostgresLockingKind] -> LockingClause
NoLockingClause :: LockingClause

-- | Identifier used for table names.
newtype Ident
I :: Text -> Ident

-- | List of identifiers already in use and supply of temporary
--   identifiers.
newtype IdentState
IdentState :: HashSet Text -> IdentState
[inUse] :: IdentState -> HashSet Text
initialIdentState :: IdentState

-- | Create a fresh Ident. If possible, use the given DBName.
newIdentFor :: DBName -> SqlQuery Ident

-- | Information needed to escape and use identifiers.
type IdentInfo = (SqlBackend, IdentState)

-- | Use an identifier.
useIdent :: IdentInfo -> Ident -> Builder
data SqlExprMeta
SqlExprMeta :: Maybe (IdentInfo -> [Builder]) -> Maybe Ident -> Bool -> SqlExprMeta
[sqlExprMetaCompositeFields] :: SqlExprMeta -> Maybe (IdentInfo -> [Builder])
[sqlExprMetaAlias] :: SqlExprMeta -> Maybe Ident
[sqlExprMetaIsReference] :: SqlExprMeta -> Bool

-- | Empty SqlExprMeta if you are constructing an ERaw
--   probably use this for your meta
noMeta :: SqlExprMeta

-- | Does this meta contain values for composite fields. This field is
--   field out for composite key values
hasCompositeKeyMeta :: SqlExprMeta -> Bool
entityAsValue :: SqlExpr (Entity val) -> SqlExpr (Value (Entity val))
entityAsValueMaybe :: SqlExpr (Maybe (Entity val)) -> SqlExpr (Value (Maybe (Entity val)))

-- | 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.
data SqlExpr a
ERaw :: SqlExprMeta -> (NeedParens -> IdentInfo -> (Builder, [PersistValue])) -> SqlExpr a

-- | The type SqlExpr a represents a SQL expression that
--   evaluates to a value that can be parsed in Haskell to an a.
--   There are often many underlying SQL values that can parse exactly. The
--   function veryUnsafeCoerceSqlExpr allows you to change this
--   type.
--   
--   There is no guarantee that the result works! To be safe, you want to
--   provide a local helper function that calls this at a tested type.
--   
--   As an example, you may know that two types share an identical SQL
--   representation, and can be parsed exactly the same way. Perhaps you
--   have a data SomeEnum which you represent as a TEXT
--   in Postgres, and you want to treat it as a TEXT. You could
--   define a top-level type-restricted alias to this which allows this to
--   be done safely:
--   
--   
--   enumToText :: SqlExpr (Value SomeEnum) -> SqlExpr (Value Text)
--   enumToText = veryUnsafeCoerceSqlExpr
--   
--   
--   Note that this is fragile: if you change the encoding of
--   SomeEnum to be anything other than Text, then your
--   code will fail at runtime.
veryUnsafeCoerceSqlExpr :: SqlExpr a -> SqlExpr b

-- | While veryUnsafeCoerceSqlExpr allows you to coerce anything at
--   all, this requires that the two types are Coercible in Haskell.
--   This is not truly safe: after all, the point of newtype is to
--   allow you to provide different instances of classes like
--   PersistFieldSql and SqlSelect. Using this may break your
--   code if you change the underlying SQL representation.
unsafeCoerceSqlExpr :: Coercible a b => SqlExpr a -> SqlExpr b

-- | Like unsafeCoerceSqlExpr but for the common case where you are
--   coercing a Value.
unsafeCoerceSqlExprValue :: Coercible a b => SqlExpr (Value a) -> SqlExpr (Value b)

-- | The type error message given when you try to do fmap on a
--   SqlExpr. This is intended to guide folks towards the docs,
--   which should guide them towards alternative implementations.
type SqlExprFunctorMessage = 'Text "You're trying to treat `SqlExpr` like a `Functor`, but it cannot be one." ':$$: 'Text "We would need to send arbitrary functions to the database for interpretation to support that instance." ':$$: 'Text "See the docs for the fake instance of `Functor SqlExpr` for more information." ':$$: 'Text "Consider using a SQL function with `unsafeSqlFunction` and a good type signature."

-- | The NullableFieldProjection type is used to determine whether a
--   Maybe should be stripped off or not. This is used in the
--   HasField for SqlExpr (Maybe (Entity
--   a)) to allow you to only have a single level of Maybe.
--   
--   
--   MyTable
--     column         Int Maybe
--     someTableId    SomeTableId
--   
--    select $ do
--        (_ :& maybeMyTable) <-
--            from $ table SomeTable
--                leftJoin table MyTable
--                    on do
--                        (someTable :& maybeMyTable) ->
--                            just someTable.id ==. maybeMyTable.someTableId
--          where_ $ maybeMyTable.column ==. just (val 10)
--          pure maybeMyTable
--   
--   
--   Without this class, projecting a field with type Maybe
--   typ would have resulted in a SqlExpr (Value
--   (Maybe (Maybe typ))).
class NullableFieldProjection typ typ'

-- | Data type to support from hack
data PreprocessedFrom a
PreprocessedFrom :: a -> FromClause -> PreprocessedFrom a

-- | Phantom type used to mark a INSERT INTO query.
data InsertFinal
data NeedParens
Parens :: NeedParens
Never :: NeedParens
parensM :: NeedParens -> Builder -> Builder
data OrderByType
ASC :: OrderByType
DESC :: OrderByType
fieldName :: (PersistEntity val, PersistField typ) => IdentInfo -> EntityField val typ -> Builder
setAux :: (PersistEntity val, PersistField typ) => EntityField val typ -> (SqlExpr (Entity val) -> SqlExpr (Value typ)) -> SqlExpr (Entity val) -> SqlExpr Update
sub :: PersistField a => Mode -> SqlQuery (SqlExpr (Value a)) -> SqlExpr (Value a)
fromDBName :: IdentInfo -> DBName -> Builder
existsHelper :: SqlQuery () -> SqlExpr (Value Bool)

-- | (Internal) Create a case statement.
--   
--   Since: 2.1.1
unsafeSqlCase :: PersistField a => [(SqlExpr (Value Bool), SqlExpr (Value a))] -> SqlExpr (Value a) -> SqlExpr (Value a)

-- | (Internal) Create a custom binary operator. You should
--   not use this function directly since its type is very general,
--   you should always use it with an explicit type signature. For example:
--   
--   
--   (==.) :: SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value Bool)
--   (==.) = unsafeSqlBinOp " = "
--   
--   
--   In the example above, we constraint the arguments to be of the same
--   type and constraint the result to be a boolean value.
unsafeSqlBinOp :: Builder -> SqlExpr (Value a) -> SqlExpr (Value b) -> SqlExpr (Value c)

-- | Similar to unsafeSqlBinOp, but may also be applied to composite
--   keys. Uses the operator given as the second argument whenever applied
--   to composite keys.
--   
--   Usage example:
--   
--   
--   (==.) :: SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value Bool)
--   (==.) = unsafeSqlBinOpComposite " = " " AND "
--   
--   
--   Persistent has a hack for implementing composite keys (see
--   ECompositeKey doc for more details), so we're forced to use a
--   hack here as well. We deconstruct ERaw values based on two
--   rules:
--   
--   
--   
- If it is a single placeholder, then it's assumed to be coming from
--   a PersistList and thus its components are separated so that
--   they may be applied to a composite key.
--   
- If it is not a single placeholder, then it's assumed to be a
--   foreign (composite or not) key, so we enforce that it has no
--   placeholders and split it on the commas.
--   
unsafeSqlBinOpComposite :: Builder -> Builder -> SqlExpr (Value a) -> SqlExpr (Value b) -> SqlExpr (Value c)

-- | (Internal) A raw SQL value. The same warning from
--   unsafeSqlBinOp applies to this function as well.
unsafeSqlValue :: Builder -> SqlExpr (Value a)
unsafeSqlEntity :: PersistEntity ent => Ident -> SqlExpr (Entity ent)
valueToFunctionArg :: IdentInfo -> SqlExpr (Value a) -> (Builder, [PersistValue])

-- | (Internal) A raw SQL function. Once again, the same warning from
--   unsafeSqlBinOp applies to this function as well.
unsafeSqlFunction :: UnsafeSqlFunctionArgument a => Builder -> a -> SqlExpr (Value b)

-- | (Internal) An unsafe SQL function to extract a subfield from a
--   compound field, e.g. datetime. See unsafeSqlBinOp for warnings.
--   
--   Since: 1.3.6.
unsafeSqlExtractSubField :: UnsafeSqlFunctionArgument a => Builder -> a -> SqlExpr (Value b)

-- | (Internal) A raw SQL function. Preserves parentheses around arguments.
--   See unsafeSqlBinOp for warnings.
unsafeSqlFunctionParens :: UnsafeSqlFunctionArgument a => Builder -> a -> SqlExpr (Value b)

-- | (Internal) An explicit SQL type cast using CAST(value as type). See
--   unsafeSqlBinOp for warnings.
unsafeSqlCastAs :: Text -> SqlExpr (Value a) -> SqlExpr (Value b)

-- | (Internal) This class allows unsafeSqlFunction to work with
--   different numbers of arguments; specifically it allows providing
--   arguments to a sql function via an n-tuple of SqlExpr (Value
--   _) values, which are not all necessarily required to be the same
--   type. There are instances for up to 10-tuples, but for sql functions
--   which take more than 10 arguments, you can also nest tuples, as e.g.
--   toArgList ((a,b),(c,d)) is the same as toArgList
--   (a,b,c,d).
class UnsafeSqlFunctionArgument a
toArgList :: UnsafeSqlFunctionArgument a => a -> [SqlExpr (Value ())]

-- | (Internal) Coerce a value's type from 'SqlExpr (Value a)' to 'SqlExpr
--   (Value b)'. You should not use this function unless you know
--   what you're doing!
--   
--   This is an alias for veryUnsafeCoerceSqlExpr with the type
--   fixed to Value.
veryUnsafeCoerceSqlExprValue :: SqlExpr (Value a) -> SqlExpr (Value b)

-- | (Internal) Coerce a value's type from 'SqlExpr (ValueList a)' to
--   'SqlExpr (Value a)'. Does not work with empty lists.
--   
--   This is an alias for veryUnsafeCoerceSqlExpr, with the type
--   fixed to ValueList and Value.
veryUnsafeCoerceSqlExprValueList :: SqlExpr (ValueList a) -> SqlExpr (Value a)

-- | (Internal) Execute an esqueleto SELECT
--   SqlQuery inside persistent's SqlPersistT monad.
rawSelectSource :: forall a r (m1 :: Type -> Type) (m2 :: Type -> Type) backend. (SqlSelect a r, MonadIO m1, MonadIO m2, SqlBackendCanRead backend) => Mode -> SqlQuery a -> ReaderT backend m1 (Acquire (ConduitT () r m2 ()))

-- | Execute an esqueleto SELECT query inside
--   persistent's SqlPersistT monad and return a
--   Source of rows.
selectSource :: forall a r backend (m :: Type -> Type). (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 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).
select :: forall a r (m :: Type -> Type) backend. (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 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
--   
selectOne :: forall a r (m :: Type -> Type) backend. (SqlSelect a r, MonadIO m, SqlBackendCanRead backend) => SqlQuery a -> ReaderT backend m (Maybe r)

-- | (Internal) Run a Source of rows.
runSource :: forall (m :: Type -> Type) r backend. Monad m => ConduitT () r (ReaderT backend m) () -> ReaderT backend m [r]

-- | (Internal) Execute an esqueleto statement inside
--   persistent's SqlPersistT monad.
rawEsqueleto :: forall (m :: Type -> Type) a r backend. (MonadIO m, SqlSelect a r, BackendCompatible SqlBackend backend) => Mode -> SqlQuery a -> ReaderT backend m Int64

-- | 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)
--   
delete :: forall (m :: Type -> Type) backend. (MonadIO m, SqlBackendCanWrite backend) => SqlQuery () -> ReaderT backend m ()

-- | Same as delete, but returns the number of rows affected.
deleteCount :: forall (m :: Type -> Type) backend. (MonadIO m, SqlBackendCanWrite backend) => SqlQuery () -> ReaderT backend m Int64

-- | 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)
--   
update :: forall (m :: Type -> Type) val backend. (MonadIO m, PersistEntity val, BackendCompatible SqlBackend (PersistEntityBackend val), SqlBackendCanWrite backend) => (SqlExpr (Entity val) -> SqlQuery ()) -> ReaderT backend m ()

-- | Same as update, but returns the number of rows affected.
updateCount :: forall (m :: Type -> Type) val backend. (MonadIO m, PersistEntity val, BackendCompatible SqlBackend (PersistEntityBackend val), SqlBackendCanWrite backend) => (SqlExpr (Entity val) -> SqlQuery ()) -> ReaderT backend m Int64
builderToText :: Builder -> Text

-- | (Internal) Pretty prints a SqlQuery into a SQL query.
--   
--   Note: if you're curious about the SQL query being generated by
--   esqueleto, instead of manually using this function (which is
--   possible but tedious), see the renderQueryToText function
--   (along with renderQuerySelect, renderQueryUpdate, etc).
toRawSql :: (SqlSelect a r, BackendCompatible SqlBackend backend) => Mode -> (backend, IdentState) -> SqlQuery a -> (Builder, [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.
renderQueryToText :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => Mode -> SqlQuery a -> 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.
renderQuerySelect :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => SqlQuery a -> 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.
renderQueryDelete :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => SqlQuery a -> 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.
renderQueryUpdate :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => SqlQuery a -> 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.
renderQueryInsertInto :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => SqlQuery a -> ReaderT backend m (Text, [PersistValue])

-- | (Internal) Mode of query being converted by toRawSql.
data Mode
SELECT :: Mode
DELETE :: Mode
UPDATE :: Mode
INSERT_INTO :: Mode
uncommas :: [Builder] -> Builder
intersperseB :: Builder -> [Builder] -> Builder
uncommas' :: Monoid a => [(Builder, a)] -> (Builder, a)
makeCte :: IdentInfo -> [CommonTableExpressionClause] -> (Builder, [PersistValue])
makeInsertInto :: SqlSelect a r => IdentInfo -> Mode -> a -> (Builder, [PersistValue])
makeSelect :: SqlSelect a r => IdentInfo -> Mode -> DistinctClause -> a -> (Builder, [PersistValue])
makeFrom :: IdentInfo -> Mode -> [FromClause] -> (Builder, [PersistValue])
makeSet :: IdentInfo -> [SetClause] -> (Builder, [PersistValue])
makeWhere :: IdentInfo -> WhereClause -> (Builder, [PersistValue])
makeGroupBy :: IdentInfo -> GroupByClause -> (Builder, [PersistValue])
makeHaving :: IdentInfo -> WhereClause -> (Builder, [PersistValue])
makeOrderByNoNewline :: IdentInfo -> [OrderByClause] -> (Builder, [PersistValue])
makeOrderBy :: IdentInfo -> [OrderByClause] -> (Builder, [PersistValue])
makeLimit :: IdentInfo -> LimitClause -> (Builder, [PersistValue])
makeLocking :: IdentInfo -> LockingClause -> (Builder, [PersistValue])
parens :: Builder -> Builder
aliasedEntityColumnIdent :: Ident -> FieldDef -> Ident
aliasedColumnName :: Ident -> IdentInfo -> Text -> Builder

-- | (Internal) Class for mapping results coming from SqlQuery into
--   actual results.
--   
--   This looks very similar to RawSql, and it is! However, there
--   are some crucial differences and ultimately they're different classes.
class SqlSelect a r | a -> r, r -> a

-- | Creates the variable part of the SELECT query and returns the
--   list of PersistValues that will be given to rawQuery.
sqlSelectCols :: SqlSelect a r => IdentInfo -> a -> (Builder, [PersistValue])

-- | Number of columns that will be consumed.
sqlSelectColCount :: SqlSelect a r => Proxy a -> Int

-- | Transform a row of the result into the data type.
sqlSelectProcessRow :: SqlSelect a r => [PersistValue] -> Either Text r

-- | Create INSERT INTO clause instead.
sqlInsertInto :: SqlSelect a r => IdentInfo -> a -> (Builder, [PersistValue])
unescapedColumnNames :: EntityDef -> [DBName]
getEntityVal :: Proxy (SqlExpr (Entity a)) -> Proxy a

-- | Materialize a SqlExpr (Value a).
materializeExpr :: IdentInfo -> SqlExpr (Value a) -> (Builder, [PersistValue])
from3P :: Proxy (a, b, c) -> Proxy ((a, b), c)
from3 :: (a, b, c) -> ((a, b), c)
to3 :: ((a, b), c) -> (a, b, c)
from4P :: Proxy (a, b, c, d) -> Proxy ((a, b), (c, d))
from4 :: (a, b, c, d) -> ((a, b), (c, d))
to4 :: ((a, b), (c, d)) -> (a, b, c, d)
from5P :: Proxy (a, b, c, d, e) -> Proxy ((a, b), (c, d), e)
from5 :: (a, b, c, d, e) -> ((a, b), (c, d), e)
to5 :: ((a, b), (c, d), e) -> (a, b, c, d, e)
from6P :: Proxy (a, b, c, d, e, f) -> Proxy ((a, b), (c, d), (e, f))
from6 :: (a, b, c, d, e, f) -> ((a, b), (c, d), (e, f))
to6 :: ((a, b), (c, d), (e, f)) -> (a, b, c, d, e, f)
from7P :: Proxy (a, b, c, d, e, f, g) -> Proxy ((a, b), (c, d), (e, f), g)
from7 :: (a, b, c, d, e, f, g) -> ((a, b), (c, d), (e, f), g)
to7 :: ((a, b), (c, d), (e, f), g) -> (a, b, c, d, e, f, g)
from8P :: Proxy (a, b, c, d, e, f, g, h) -> Proxy ((a, b), (c, d), (e, f), (g, h))
from8 :: (a, b, c, d, e, f, g, h) -> ((a, b), (c, d), (e, f), (g, h))
to8 :: ((a, b), (c, d), (e, f), (g, h)) -> (a, b, c, d, e, f, g, h)
from9P :: Proxy (a, b, c, d, e, f, g, h, i) -> Proxy ((a, b), (c, d), (e, f), (g, h), i)
from9 :: (a, b, c, d, e, f, g, h, i) -> ((a, b), (c, d), (e, f), (g, h), i)
to9 :: ((a, b), (c, d), (e, f), (g, h), i) -> (a, b, c, d, e, f, g, h, i)
from10P :: Proxy (a, b, c, d, e, f, g, h, i, j) -> Proxy ((a, b), (c, d), (e, f), (g, h), (i, j))
from10 :: (a, b, c, d, e, f, g, h, i, j) -> ((a, b), (c, d), (e, f), (g, h), (i, j))
to10 :: ((a, b), (c, d), (e, f), (g, h), (i, j)) -> (a, b, c, d, e, f, g, h, i, j)
from11P :: Proxy (a, b, c, d, e, f, g, h, i, j, k) -> Proxy ((a, b), (c, d), (e, f), (g, h), (i, j), k)
from11 :: (a, b, c, d, e, f, g, h, i, j, k) -> ((a, b), (c, d), (e, f), (g, h), (i, j), k)
to11 :: ((a, b), (c, d), (e, f), (g, h), (i, j), k) -> (a, b, c, d, e, f, g, h, i, j, k)
from12P :: Proxy (a, b, c, d, e, f, g, h, i, j, k, l) -> Proxy ((a, b), (c, d), (e, f), (g, h), (i, j), (k, l))
from12 :: (a, b, c, d, e, f, g, h, i, j, k, l) -> ((a, b), (c, d), (e, f), (g, h), (i, j), (k, l))
to12 :: ((a, b), (c, d), (e, f), (g, h), (i, j), (k, l)) -> (a, b, c, d, e, f, g, h, i, j, k, l)
from13P :: Proxy (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Proxy ((a, b), (c, d), (e, f), (g, h), (i, j), (k, l), m)
from13 :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> ((a, b), (c, d), (e, f), (g, h), (i, j), (k, l), m)
to13 :: ((a, b), (c, d), (e, f), (g, h), (i, j), (k, l), m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m)
from14P :: Proxy (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Proxy ((a, b), (c, d), (e, f), (g, h), (i, j), (k, l), (m, n))
from14 :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> ((a, b), (c, d), (e, f), (g, h), (i, j), (k, l), (m, n))
to14 :: ((a, b), (c, d), (e, f), (g, h), (i, j), (k, l), (m, n)) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
from15P :: Proxy (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Proxy ((a, b), (c, d), (e, f), (g, h), (i, j), (k, l), (m, n), o)
from15 :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> ((a, b), (c, d), (e, f), (g, h), (i, j), (k, l), (m, n), o)
to15 :: ((a, b), (c, d), (e, f), (g, h), (i, j), (k, l), (m, n), o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
from16P :: Proxy (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) -> Proxy ((a, b), (c, d), (e, f), (g, h), (i, j), (k, l), (m, n), (o, p))
from16 :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) -> ((a, b), (c, d), (e, f), (g, h), (i, j), (k, l), (m, n), (o, p))
to16 :: ((a, b), (c, d), (e, f), (g, h), (i, j), (k, l), (m, n), (o, p)) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)

-- | Insert a PersistField for every selected value.
insertSelect :: forall (m :: Type -> Type) a backend. (MonadIO m, PersistEntity a, SqlBackendCanWrite backend) => SqlQuery (SqlExpr (Insertion a)) -> ReaderT backend m ()

-- | Insert a PersistField for every selected value, return the
--   count afterward
insertSelectCount :: forall (m :: Type -> Type) a backend. (MonadIO m, PersistEntity a, SqlBackendCanWrite backend) => SqlQuery (SqlExpr (Insertion a)) -> ReaderT backend m Int64

-- | Renders an expression into Text. Only useful for creating a
--   textual representation of the clauses passed to an On clause.
renderExpr :: SqlBackend -> SqlExpr (Value Bool) -> Text

-- | An exception thrown by RenderExpr - it's not designed to
--   handle composite keys, and will blow up if you give it one.
data RenderExprException
RenderExprUnexpectedECompositeKey :: Text -> RenderExprException

-- | valkey i = val . toSqlKey
--   (https://github.com/prowdsponsor/esqueleto/issues/9).
valkey :: (ToBackendKey SqlBackend entity, PersistField (Key entity)) => Int64 -> 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).
valJ :: PersistField (Key entity) => Value (Key entity) -> SqlExpr (Value (Key entity))

-- | Synonym for delete that does not clash with
--   esqueleto's delete.
deleteKey :: forall backend val (m :: Type -> Type). (PersistStore backend, BaseBackend backend ~ PersistEntityBackend val, MonadIO m, PersistEntity val) => Key val -> ReaderT backend m ()

-- | 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.
associateJoin :: forall e1 e0. Ord (Key e0) => [(Entity e0, e1)] -> Map (Key e0) (e0, [e1])
type family Nullable a
instance GHC.Internal.Base.Applicative Database.Esqueleto.Internal.Internal.SqlQuery
instance GHC.Internal.Base.Applicative Database.Esqueleto.Internal.Internal.Value
instance Data.Bifunctor.Bifunctor (Database.Esqueleto.Internal.Internal.:&)
instance (GHC.Classes.Eq a, GHC.Classes.Eq b) => GHC.Classes.Eq (a Database.Esqueleto.Internal.Internal.:& b)
instance GHC.Classes.Eq Database.Esqueleto.Internal.Internal.CommonTableExpressionKind
instance GHC.Classes.Eq Database.Esqueleto.Internal.Internal.Ident
instance GHC.Classes.Eq Database.Esqueleto.Internal.Internal.JoinKind
instance GHC.Classes.Eq Database.Esqueleto.Internal.Internal.LimitClause
instance GHC.Classes.Eq Database.Esqueleto.Internal.Internal.NeedParens
instance GHC.Classes.Eq Database.Esqueleto.Internal.Internal.OnClauseWithoutMatchingJoinException
instance GHC.Classes.Eq Database.Esqueleto.Internal.Internal.OnLockedBehavior
instance GHC.Classes.Eq Database.Esqueleto.Internal.Internal.PostgresRowLevelLockStrength
instance GHC.Classes.Eq a => GHC.Classes.Eq (Database.Esqueleto.Internal.Internal.Value a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Database.Esqueleto.Internal.Internal.ValueList a)
instance GHC.Internal.Exception.Type.Exception Database.Esqueleto.Internal.Internal.EsqueletoError
instance GHC.Internal.Exception.Type.Exception Database.Esqueleto.Internal.Internal.OnClauseWithoutMatchingJoinException
instance GHC.Internal.Exception.Type.Exception Database.Esqueleto.Internal.Internal.RenderExprException
instance Database.Esqueleto.Internal.Internal.FinalResult b => Database.Esqueleto.Internal.Internal.FinalResult (a -> b)
instance Database.Esqueleto.Internal.Internal.FinalResult (Database.Persist.Class.PersistEntity.Unique val)
instance GHC.Internal.Data.Foldable.Foldable Database.Esqueleto.Internal.Internal.Value
instance (Database.Persist.Class.PersistEntity.PersistEntity val, Database.Persist.Class.PersistStore.BackendCompatible Database.Persist.SqlBackend.Internal.SqlBackend (Database.Persist.Class.PersistEntity.PersistEntityBackend val)) => Database.Esqueleto.Internal.Internal.FromPreprocess (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Persist.Class.PersistEntity.Entity val))
instance (Database.Persist.Class.PersistEntity.PersistEntity val, Database.Persist.Class.PersistStore.BackendCompatible Database.Persist.SqlBackend.Internal.SqlBackend (Database.Persist.Class.PersistEntity.PersistEntityBackend val)) => Database.Esqueleto.Internal.Internal.FromPreprocess (Database.Esqueleto.Internal.Internal.SqlExpr (GHC.Internal.Maybe.Maybe (Database.Persist.Class.PersistEntity.Entity val)))
instance (Database.Esqueleto.Internal.Internal.FromPreprocess a, Database.Esqueleto.Internal.Internal.FromPreprocess b, Database.Esqueleto.Internal.Internal.IsJoinKind join) => Database.Esqueleto.Internal.Internal.FromPreprocess (join a b)
instance Database.Esqueleto.Internal.Internal.FromPreprocess (Database.Esqueleto.Internal.Internal.CrossJoin a b) => Database.Esqueleto.Internal.Internal.From (Database.Esqueleto.Internal.Internal.CrossJoin a b)
instance Database.Esqueleto.Internal.Internal.FromPreprocess (Database.Esqueleto.Internal.Internal.FullOuterJoin a b) => Database.Esqueleto.Internal.Internal.From (Database.Esqueleto.Internal.Internal.FullOuterJoin a b)
instance Database.Esqueleto.Internal.Internal.FromPreprocess (Database.Esqueleto.Internal.Internal.InnerJoin a b) => Database.Esqueleto.Internal.Internal.From (Database.Esqueleto.Internal.Internal.InnerJoin a b)
instance Database.Esqueleto.Internal.Internal.FromPreprocess (Database.Esqueleto.Internal.Internal.LeftOuterJoin a b) => Database.Esqueleto.Internal.Internal.From (Database.Esqueleto.Internal.Internal.LeftOuterJoin a b)
instance Database.Esqueleto.Internal.Internal.FromPreprocess (Database.Esqueleto.Internal.Internal.RightOuterJoin a b) => Database.Esqueleto.Internal.Internal.From (Database.Esqueleto.Internal.Internal.RightOuterJoin a b)
instance Database.Esqueleto.Internal.Internal.FromPreprocess (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Persist.Class.PersistEntity.Entity val)) => Database.Esqueleto.Internal.Internal.From (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Persist.Class.PersistEntity.Entity val))
instance Database.Esqueleto.Internal.Internal.FromPreprocess (Database.Esqueleto.Internal.Internal.SqlExpr (GHC.Internal.Maybe.Maybe (Database.Persist.Class.PersistEntity.Entity val))) => Database.Esqueleto.Internal.Internal.From (Database.Esqueleto.Internal.Internal.SqlExpr (GHC.Internal.Maybe.Maybe (Database.Persist.Class.PersistEntity.Entity val)))
instance (Database.Esqueleto.Internal.Internal.From a, Database.Esqueleto.Internal.Internal.From b) => Database.Esqueleto.Internal.Internal.From (a, b)
instance (Database.Esqueleto.Internal.Internal.From a, Database.Esqueleto.Internal.Internal.From b, Database.Esqueleto.Internal.Internal.From c) => Database.Esqueleto.Internal.Internal.From (a, b, c)
instance (Database.Esqueleto.Internal.Internal.From a, Database.Esqueleto.Internal.Internal.From b, Database.Esqueleto.Internal.Internal.From c, Database.Esqueleto.Internal.Internal.From d) => Database.Esqueleto.Internal.Internal.From (a, b, c, d)
instance (Database.Esqueleto.Internal.Internal.From a, Database.Esqueleto.Internal.Internal.From b, Database.Esqueleto.Internal.Internal.From c, Database.Esqueleto.Internal.Internal.From d, Database.Esqueleto.Internal.Internal.From e) => Database.Esqueleto.Internal.Internal.From (a, b, c, d, e)
instance (Database.Esqueleto.Internal.Internal.From a, Database.Esqueleto.Internal.Internal.From b, Database.Esqueleto.Internal.Internal.From c, Database.Esqueleto.Internal.Internal.From d, Database.Esqueleto.Internal.Internal.From e, Database.Esqueleto.Internal.Internal.From f) => Database.Esqueleto.Internal.Internal.From (a, b, c, d, e, f)
instance (Database.Esqueleto.Internal.Internal.From a, Database.Esqueleto.Internal.Internal.From b, Database.Esqueleto.Internal.Internal.From c, Database.Esqueleto.Internal.Internal.From d, Database.Esqueleto.Internal.Internal.From e, Database.Esqueleto.Internal.Internal.From f, Database.Esqueleto.Internal.Internal.From g) => Database.Esqueleto.Internal.Internal.From (a, b, c, d, e, f, g)
instance (Database.Esqueleto.Internal.Internal.From a, Database.Esqueleto.Internal.Internal.From b, Database.Esqueleto.Internal.Internal.From c, Database.Esqueleto.Internal.Internal.From d, Database.Esqueleto.Internal.Internal.From e, Database.Esqueleto.Internal.Internal.From f, Database.Esqueleto.Internal.Internal.From g, Database.Esqueleto.Internal.Internal.From h) => Database.Esqueleto.Internal.Internal.From (a, b, c, d, e, f, g, h)
instance GHC.Internal.Base.Functor ((Database.Esqueleto.Internal.Internal.:&) a)
instance (TypeError ...) => GHC.Internal.Base.Functor Database.Esqueleto.Internal.Internal.SqlExpr
instance GHC.Internal.Base.Functor Database.Esqueleto.Internal.Internal.SqlQuery
instance GHC.Internal.Base.Functor Database.Esqueleto.Internal.Internal.Value
instance (Database.Persist.Class.PersistEntity.PersistEntity rec, Database.Persist.Class.PersistField.PersistField typ, Database.Persist.Class.PersistEntity.SymbolToField sym rec typ) => GHC.Internal.Records.HasField sym (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Persist.Class.PersistEntity.Entity rec)) (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Esqueleto.Internal.Internal.Value typ))
instance (Database.Persist.Class.PersistEntity.PersistEntity rec, Database.Persist.Class.PersistField.PersistField typ, Database.Persist.Class.PersistField.PersistField typ', Database.Persist.Class.PersistEntity.SymbolToField sym rec typ, Database.Esqueleto.Internal.Internal.NullableFieldProjection typ typ', GHC.Internal.Records.HasField sym (Database.Esqueleto.Internal.Internal.SqlExpr (GHC.Internal.Maybe.Maybe (Database.Persist.Class.PersistEntity.Entity rec))) (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Esqueleto.Internal.Internal.Value (GHC.Internal.Maybe.Maybe typ')))) => GHC.Internal.Records.HasField sym (Database.Esqueleto.Internal.Internal.SqlExpr (GHC.Internal.Maybe.Maybe (Database.Persist.Class.PersistEntity.Entity rec))) (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Esqueleto.Internal.Internal.Value (GHC.Internal.Maybe.Maybe typ')))
instance Database.Esqueleto.Internal.Internal.IsJoinKind Database.Esqueleto.Internal.Internal.CrossJoin
instance Database.Esqueleto.Internal.Internal.IsJoinKind Database.Esqueleto.Internal.Internal.FullOuterJoin
instance Database.Esqueleto.Internal.Internal.IsJoinKind Database.Esqueleto.Internal.Internal.InnerJoin
instance Database.Esqueleto.Internal.Internal.IsJoinKind Database.Esqueleto.Internal.Internal.LeftOuterJoin
instance Database.Esqueleto.Internal.Internal.IsJoinKind Database.Esqueleto.Internal.Internal.RightOuterJoin
instance (Database.Esqueleto.Internal.Internal.LockableEntity a, Database.Esqueleto.Internal.Internal.LockableEntity b) => Database.Esqueleto.Internal.Internal.LockableEntity (a Database.Esqueleto.Internal.Internal.:& b)
instance Database.Persist.Class.PersistEntity.PersistEntity val => Database.Esqueleto.Internal.Internal.LockableEntity (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Persist.Class.PersistEntity.Entity val))
instance GHC.Internal.Base.Monad Database.Esqueleto.Internal.Internal.SqlQuery
instance GHC.Internal.Base.Monad Database.Esqueleto.Internal.Internal.Value
instance GHC.Internal.Base.Monoid Database.Esqueleto.Internal.Internal.DistinctClause
instance GHC.Internal.Base.Monoid Database.Esqueleto.Internal.Internal.GroupByClause
instance GHC.Internal.Base.Monoid Database.Esqueleto.Internal.Internal.LimitClause
instance GHC.Internal.Base.Monoid Database.Esqueleto.Internal.Internal.LockingClause
instance GHC.Internal.Base.Monoid Database.Esqueleto.Internal.Internal.SideData
instance GHC.Internal.Base.Monoid Database.Esqueleto.Internal.Internal.WhereClause
instance (typ GHC.Types.~ typ') => Database.Esqueleto.Internal.Internal.NullableFieldProjection (GHC.Internal.Maybe.Maybe typ) typ'
instance (typ GHC.Types.~ typ') => Database.Esqueleto.Internal.Internal.NullableFieldProjection typ typ'
instance GHC.Classes.Ord Database.Esqueleto.Internal.Internal.Ident
instance GHC.Classes.Ord Database.Esqueleto.Internal.Internal.OnClauseWithoutMatchingJoinException
instance GHC.Classes.Ord Database.Esqueleto.Internal.Internal.OnLockedBehavior
instance GHC.Classes.Ord Database.Esqueleto.Internal.Internal.PostgresRowLevelLockStrength
instance GHC.Classes.Ord a => GHC.Classes.Ord (Database.Esqueleto.Internal.Internal.Value a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Database.Esqueleto.Internal.Internal.ValueList a)
instance GHC.Internal.Base.Semigroup Database.Esqueleto.Internal.Internal.DistinctClause
instance GHC.Internal.Base.Semigroup Database.Esqueleto.Internal.Internal.GroupByClause
instance GHC.Internal.Base.Semigroup Database.Esqueleto.Internal.Internal.LimitClause
instance GHC.Internal.Base.Semigroup Database.Esqueleto.Internal.Internal.LockingClause
instance GHC.Internal.Base.Semigroup Database.Esqueleto.Internal.Internal.SideData
instance GHC.Internal.Base.Semigroup Database.Esqueleto.Internal.Internal.WhereClause
instance (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b) => GHC.Internal.Show.Show (a Database.Esqueleto.Internal.Internal.:& b)
instance GHC.Internal.Show.Show Database.Esqueleto.Internal.Internal.EsqueletoError
instance GHC.Internal.Show.Show Database.Esqueleto.Internal.Internal.FromClause
instance GHC.Internal.Show.Show Database.Esqueleto.Internal.Internal.Ident
instance GHC.Internal.Show.Show Database.Esqueleto.Internal.Internal.JoinKind
instance GHC.Internal.Show.Show Database.Esqueleto.Internal.Internal.OnClauseWithoutMatchingJoinException
instance GHC.Internal.Show.Show Database.Esqueleto.Internal.Internal.OnLockedBehavior
instance GHC.Internal.Show.Show Database.Esqueleto.Internal.Internal.RenderExprException
instance GHC.Internal.Show.Show Database.Esqueleto.Internal.Internal.SqlBinOpCompositeError
instance GHC.Internal.Show.Show Database.Esqueleto.Internal.Internal.SubQueryType
instance GHC.Internal.Show.Show Database.Esqueleto.Internal.Internal.UnexpectedCaseError
instance GHC.Internal.Show.Show Database.Esqueleto.Internal.Internal.UnexpectedValueError
instance GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Database.Esqueleto.Internal.Internal.Value a)
instance GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Database.Esqueleto.Internal.Internal.ValueList a)
instance Database.Persist.Class.PersistEntity.PersistEntity a => Database.Esqueleto.Internal.Internal.SqlSelect (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Persist.Class.PersistEntity.Entity a)) (Database.Persist.Class.PersistEntity.Entity a)
instance Database.Persist.Class.PersistEntity.PersistEntity e => Database.Esqueleto.Internal.Internal.SqlSelect (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Esqueleto.Internal.Internal.Insertion e)) (Database.Esqueleto.Internal.Internal.Insertion e)
instance Database.Persist.Class.PersistEntity.PersistEntity a => Database.Esqueleto.Internal.Internal.SqlSelect (Database.Esqueleto.Internal.Internal.SqlExpr (GHC.Internal.Maybe.Maybe (Database.Persist.Class.PersistEntity.Entity a))) (GHC.Internal.Maybe.Maybe (Database.Persist.Class.PersistEntity.Entity a))
instance Database.Persist.Class.PersistField.PersistField a => Database.Esqueleto.Internal.Internal.SqlSelect (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Esqueleto.Internal.Internal.Value a)) (Database.Esqueleto.Internal.Internal.Value a)
instance (Database.Esqueleto.Internal.Internal.SqlSelect a ra, Database.Esqueleto.Internal.Internal.SqlSelect b rb, Database.Esqueleto.Internal.Internal.SqlSelect c rc, Database.Esqueleto.Internal.Internal.SqlSelect d rd, Database.Esqueleto.Internal.Internal.SqlSelect e re, Database.Esqueleto.Internal.Internal.SqlSelect f rf, Database.Esqueleto.Internal.Internal.SqlSelect g rg, Database.Esqueleto.Internal.Internal.SqlSelect h rh, Database.Esqueleto.Internal.Internal.SqlSelect i ri, Database.Esqueleto.Internal.Internal.SqlSelect j rj) => Database.Esqueleto.Internal.Internal.SqlSelect (a, b, c, d, e, f, g, h, i, j) (ra, rb, rc, rd, re, rf, rg, rh, ri, rj)
instance (Database.Esqueleto.Internal.Internal.SqlSelect a ra, Database.Esqueleto.Internal.Internal.SqlSelect b rb, Database.Esqueleto.Internal.Internal.SqlSelect c rc, Database.Esqueleto.Internal.Internal.SqlSelect d rd, Database.Esqueleto.Internal.Internal.SqlSelect e re, Database.Esqueleto.Internal.Internal.SqlSelect f rf, Database.Esqueleto.Internal.Internal.SqlSelect g rg, Database.Esqueleto.Internal.Internal.SqlSelect h rh, Database.Esqueleto.Internal.Internal.SqlSelect i ri, Database.Esqueleto.Internal.Internal.SqlSelect j rj, Database.Esqueleto.Internal.Internal.SqlSelect k rk) => Database.Esqueleto.Internal.Internal.SqlSelect (a, b, c, d, e, f, g, h, i, j, k) (ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk)
instance (Database.Esqueleto.Internal.Internal.SqlSelect a ra, Database.Esqueleto.Internal.Internal.SqlSelect b rb, Database.Esqueleto.Internal.Internal.SqlSelect c rc, Database.Esqueleto.Internal.Internal.SqlSelect d rd, Database.Esqueleto.Internal.Internal.SqlSelect e re, Database.Esqueleto.Internal.Internal.SqlSelect f rf, Database.Esqueleto.Internal.Internal.SqlSelect g rg, Database.Esqueleto.Internal.Internal.SqlSelect h rh, Database.Esqueleto.Internal.Internal.SqlSelect i ri, Database.Esqueleto.Internal.Internal.SqlSelect j rj, Database.Esqueleto.Internal.Internal.SqlSelect k rk, Database.Esqueleto.Internal.Internal.SqlSelect l rl) => Database.Esqueleto.Internal.Internal.SqlSelect (a, b, c, d, e, f, g, h, i, j, k, l) (ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl)
instance (Database.Esqueleto.Internal.Internal.SqlSelect a ra, Database.Esqueleto.Internal.Internal.SqlSelect b rb, Database.Esqueleto.Internal.Internal.SqlSelect c rc, Database.Esqueleto.Internal.Internal.SqlSelect d rd, Database.Esqueleto.Internal.Internal.SqlSelect e re, Database.Esqueleto.Internal.Internal.SqlSelect f rf, Database.Esqueleto.Internal.Internal.SqlSelect g rg, Database.Esqueleto.Internal.Internal.SqlSelect h rh, Database.Esqueleto.Internal.Internal.SqlSelect i ri, Database.Esqueleto.Internal.Internal.SqlSelect j rj, Database.Esqueleto.Internal.Internal.SqlSelect k rk, Database.Esqueleto.Internal.Internal.SqlSelect l rl, Database.Esqueleto.Internal.Internal.SqlSelect m rm) => Database.Esqueleto.Internal.Internal.SqlSelect (a, b, c, d, e, f, g, h, i, j, k, l, m) (ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm)
instance (Database.Esqueleto.Internal.Internal.SqlSelect a ra, Database.Esqueleto.Internal.Internal.SqlSelect b rb, Database.Esqueleto.Internal.Internal.SqlSelect c rc, Database.Esqueleto.Internal.Internal.SqlSelect d rd, Database.Esqueleto.Internal.Internal.SqlSelect e re, Database.Esqueleto.Internal.Internal.SqlSelect f rf, Database.Esqueleto.Internal.Internal.SqlSelect g rg, Database.Esqueleto.Internal.Internal.SqlSelect h rh, Database.Esqueleto.Internal.Internal.SqlSelect i ri, Database.Esqueleto.Internal.Internal.SqlSelect j rj, Database.Esqueleto.Internal.Internal.SqlSelect k rk, Database.Esqueleto.Internal.Internal.SqlSelect l rl, Database.Esqueleto.Internal.Internal.SqlSelect m rm, Database.Esqueleto.Internal.Internal.SqlSelect n rn) => Database.Esqueleto.Internal.Internal.SqlSelect (a, b, c, d, e, f, g, h, i, j, k, l, m, n) (ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm, rn)
instance (Database.Esqueleto.Internal.Internal.SqlSelect a ra, Database.Esqueleto.Internal.Internal.SqlSelect b rb, Database.Esqueleto.Internal.Internal.SqlSelect c rc, Database.Esqueleto.Internal.Internal.SqlSelect d rd, Database.Esqueleto.Internal.Internal.SqlSelect e re, Database.Esqueleto.Internal.Internal.SqlSelect f rf, Database.Esqueleto.Internal.Internal.SqlSelect g rg, Database.Esqueleto.Internal.Internal.SqlSelect h rh, Database.Esqueleto.Internal.Internal.SqlSelect i ri, Database.Esqueleto.Internal.Internal.SqlSelect j rj, Database.Esqueleto.Internal.Internal.SqlSelect k rk, Database.Esqueleto.Internal.Internal.SqlSelect l rl, Database.Esqueleto.Internal.Internal.SqlSelect m rm, Database.Esqueleto.Internal.Internal.SqlSelect n rn, Database.Esqueleto.Internal.Internal.SqlSelect o ro) => Database.Esqueleto.Internal.Internal.SqlSelect (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) (ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm, rn, ro)
instance (Database.Esqueleto.Internal.Internal.SqlSelect a ra, Database.Esqueleto.Internal.Internal.SqlSelect b rb, Database.Esqueleto.Internal.Internal.SqlSelect c rc, Database.Esqueleto.Internal.Internal.SqlSelect d rd, Database.Esqueleto.Internal.Internal.SqlSelect e re, Database.Esqueleto.Internal.Internal.SqlSelect f rf, Database.Esqueleto.Internal.Internal.SqlSelect g rg, Database.Esqueleto.Internal.Internal.SqlSelect h rh, Database.Esqueleto.Internal.Internal.SqlSelect i ri, Database.Esqueleto.Internal.Internal.SqlSelect j rj, Database.Esqueleto.Internal.Internal.SqlSelect k rk, Database.Esqueleto.Internal.Internal.SqlSelect l rl, Database.Esqueleto.Internal.Internal.SqlSelect m rm, Database.Esqueleto.Internal.Internal.SqlSelect n rn, Database.Esqueleto.Internal.Internal.SqlSelect o ro, Database.Esqueleto.Internal.Internal.SqlSelect p rp) => Database.Esqueleto.Internal.Internal.SqlSelect (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) (ra, rb, rc, rd, re, rf, rg, rh, ri, rj, rk, rl, rm, rn, ro, rp)
instance (Database.Esqueleto.Internal.Internal.SqlSelect a ra, Database.Esqueleto.Internal.Internal.SqlSelect b rb) => Database.Esqueleto.Internal.Internal.SqlSelect (a, b) (ra, rb)
instance (Database.Esqueleto.Internal.Internal.SqlSelect a ra, Database.Esqueleto.Internal.Internal.SqlSelect b rb, Database.Esqueleto.Internal.Internal.SqlSelect c rc) => Database.Esqueleto.Internal.Internal.SqlSelect (a, b, c) (ra, rb, rc)
instance (Database.Esqueleto.Internal.Internal.SqlSelect a ra, Database.Esqueleto.Internal.Internal.SqlSelect b rb, Database.Esqueleto.Internal.Internal.SqlSelect c rc, Database.Esqueleto.Internal.Internal.SqlSelect d rd) => Database.Esqueleto.Internal.Internal.SqlSelect (a, b, c, d) (ra, rb, rc, rd)
instance (Database.Esqueleto.Internal.Internal.SqlSelect a ra, Database.Esqueleto.Internal.Internal.SqlSelect b rb, Database.Esqueleto.Internal.Internal.SqlSelect c rc, Database.Esqueleto.Internal.Internal.SqlSelect d rd, Database.Esqueleto.Internal.Internal.SqlSelect e re) => Database.Esqueleto.Internal.Internal.SqlSelect (a, b, c, d, e) (ra, rb, rc, rd, re)
instance (Database.Esqueleto.Internal.Internal.SqlSelect a ra, Database.Esqueleto.Internal.Internal.SqlSelect b rb, Database.Esqueleto.Internal.Internal.SqlSelect c rc, Database.Esqueleto.Internal.Internal.SqlSelect d rd, Database.Esqueleto.Internal.Internal.SqlSelect e re, Database.Esqueleto.Internal.Internal.SqlSelect f rf) => Database.Esqueleto.Internal.Internal.SqlSelect (a, b, c, d, e, f) (ra, rb, rc, rd, re, rf)
instance (Database.Esqueleto.Internal.Internal.SqlSelect a ra, Database.Esqueleto.Internal.Internal.SqlSelect b rb, Database.Esqueleto.Internal.Internal.SqlSelect c rc, Database.Esqueleto.Internal.Internal.SqlSelect d rd, Database.Esqueleto.Internal.Internal.SqlSelect e re, Database.Esqueleto.Internal.Internal.SqlSelect f rf, Database.Esqueleto.Internal.Internal.SqlSelect g rg) => Database.Esqueleto.Internal.Internal.SqlSelect (a, b, c, d, e, f, g) (ra, rb, rc, rd, re, rf, rg)
instance (Database.Esqueleto.Internal.Internal.SqlSelect a ra, Database.Esqueleto.Internal.Internal.SqlSelect b rb, Database.Esqueleto.Internal.Internal.SqlSelect c rc, Database.Esqueleto.Internal.Internal.SqlSelect d rd, Database.Esqueleto.Internal.Internal.SqlSelect e re, Database.Esqueleto.Internal.Internal.SqlSelect f rf, Database.Esqueleto.Internal.Internal.SqlSelect g rg, Database.Esqueleto.Internal.Internal.SqlSelect h rh) => Database.Esqueleto.Internal.Internal.SqlSelect (a, b, c, d, e, f, g, h) (ra, rb, rc, rd, re, rf, rg, rh)
instance (Database.Esqueleto.Internal.Internal.SqlSelect a ra, Database.Esqueleto.Internal.Internal.SqlSelect b rb, Database.Esqueleto.Internal.Internal.SqlSelect c rc, Database.Esqueleto.Internal.Internal.SqlSelect d rd, Database.Esqueleto.Internal.Internal.SqlSelect e re, Database.Esqueleto.Internal.Internal.SqlSelect f rf, Database.Esqueleto.Internal.Internal.SqlSelect g rg, Database.Esqueleto.Internal.Internal.SqlSelect h rh, Database.Esqueleto.Internal.Internal.SqlSelect i ri) => Database.Esqueleto.Internal.Internal.SqlSelect (a, b, c, d, e, f, g, h, i) (ra, rb, rc, rd, re, rf, rg, rh, ri)
instance Database.Esqueleto.Internal.Internal.SqlSelect () ()
instance Database.Esqueleto.Internal.Internal.SqlString Data.ByteString.Internal.Type.ByteString
instance (a GHC.Types.~ GHC.Types.Char) => Database.Esqueleto.Internal.Internal.SqlString [a]
instance Database.Esqueleto.Internal.Internal.SqlString Text.Blaze.Html.Html
instance Database.Esqueleto.Internal.Internal.SqlString a => Database.Esqueleto.Internal.Internal.SqlString (GHC.Internal.Maybe.Maybe a)
instance Database.Esqueleto.Internal.Internal.SqlString Data.Text.Internal.Lazy.Text
instance Database.Esqueleto.Internal.Internal.SqlString Data.Text.Internal.Text
instance Database.Esqueleto.Internal.Internal.ToSomeValues (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Esqueleto.Internal.Internal.Value a))
instance (Database.Esqueleto.Internal.Internal.ToSomeValues a, Database.Esqueleto.Internal.Internal.ToSomeValues b) => Database.Esqueleto.Internal.Internal.ToSomeValues (a, b)
instance (Database.Esqueleto.Internal.Internal.ToSomeValues a, Database.Esqueleto.Internal.Internal.ToSomeValues b, Database.Esqueleto.Internal.Internal.ToSomeValues c) => Database.Esqueleto.Internal.Internal.ToSomeValues (a, b, c)
instance (Database.Esqueleto.Internal.Internal.ToSomeValues a, Database.Esqueleto.Internal.Internal.ToSomeValues b, Database.Esqueleto.Internal.Internal.ToSomeValues c, Database.Esqueleto.Internal.Internal.ToSomeValues d) => Database.Esqueleto.Internal.Internal.ToSomeValues (a, b, c, d)
instance (Database.Esqueleto.Internal.Internal.ToSomeValues a, Database.Esqueleto.Internal.Internal.ToSomeValues b, Database.Esqueleto.Internal.Internal.ToSomeValues c, Database.Esqueleto.Internal.Internal.ToSomeValues d, Database.Esqueleto.Internal.Internal.ToSomeValues e) => Database.Esqueleto.Internal.Internal.ToSomeValues (a, b, c, d, e)
instance (Database.Esqueleto.Internal.Internal.ToSomeValues a, Database.Esqueleto.Internal.Internal.ToSomeValues b, Database.Esqueleto.Internal.Internal.ToSomeValues c, Database.Esqueleto.Internal.Internal.ToSomeValues d, Database.Esqueleto.Internal.Internal.ToSomeValues e, Database.Esqueleto.Internal.Internal.ToSomeValues f) => Database.Esqueleto.Internal.Internal.ToSomeValues (a, b, c, d, e, f)
instance (Database.Esqueleto.Internal.Internal.ToSomeValues a, Database.Esqueleto.Internal.Internal.ToSomeValues b, Database.Esqueleto.Internal.Internal.ToSomeValues c, Database.Esqueleto.Internal.Internal.ToSomeValues d, Database.Esqueleto.Internal.Internal.ToSomeValues e, Database.Esqueleto.Internal.Internal.ToSomeValues f, Database.Esqueleto.Internal.Internal.ToSomeValues g) => Database.Esqueleto.Internal.Internal.ToSomeValues (a, b, c, d, e, f, g)
instance (Database.Esqueleto.Internal.Internal.ToSomeValues a, Database.Esqueleto.Internal.Internal.ToSomeValues b, Database.Esqueleto.Internal.Internal.ToSomeValues c, Database.Esqueleto.Internal.Internal.ToSomeValues d, Database.Esqueleto.Internal.Internal.ToSomeValues e, Database.Esqueleto.Internal.Internal.ToSomeValues f, Database.Esqueleto.Internal.Internal.ToSomeValues g, Database.Esqueleto.Internal.Internal.ToSomeValues h) => Database.Esqueleto.Internal.Internal.ToSomeValues (a, b, c, d, e, f, g, h)
instance GHC.Internal.Data.Traversable.Traversable Database.Esqueleto.Internal.Internal.Value
instance Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument a => Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument [a]
instance (a GHC.Types.~ Database.Esqueleto.Internal.Internal.Value b) => Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument (Database.Esqueleto.Internal.Internal.SqlExpr a)
instance (Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument a, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument b, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument c, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument d, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument e, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument f, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument g, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument h, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument i, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument j) => Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument (a, b, c, d, e, f, g, h, i, j)
instance (Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument a, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument b) => Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument (a, b)
instance (Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument a, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument b, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument c) => Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument (a, b, c)
instance (Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument a, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument b, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument c, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument d) => Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument (a, b, c, d)
instance (Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument a, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument b, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument c, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument d, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument e) => Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument (a, b, c, d, e)
instance (Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument a, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument b, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument c, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument d, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument e, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument f) => Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument (a, b, c, d, e, f)
instance (Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument a, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument b, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument c, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument d, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument e, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument f, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument g) => Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument (a, b, c, d, e, f, g)
instance (Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument a, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument b, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument c, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument d, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument e, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument f, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument g, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument h) => Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument (a, b, c, d, e, f, g, h)
instance (Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument a, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument b, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument c, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument d, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument e, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument f, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument g, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument h, Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument i) => Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument (a, b, c, d, e, f, g, h, i)
instance Database.Esqueleto.Internal.Internal.UnsafeSqlFunctionArgument ()

module Database.Esqueleto.Experimental.ToMaybe
class ToMaybe a where {
    type ToMaybeT a;
}
toMaybe :: ToMaybe a => a -> ToMaybeT a
type family ToMaybeT a
type family Nullable a
instance Database.Esqueleto.Experimental.ToMaybe.ToMaybe (Database.Esqueleto.Internal.Internal.SqlExpr (GHC.Internal.Maybe.Maybe a))
instance Database.Esqueleto.Experimental.ToMaybe.ToMaybe (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Persist.Class.PersistEntity.Entity a))
instance Database.Esqueleto.Experimental.ToMaybe.ToMaybe (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Esqueleto.Internal.Internal.Value a))
instance (Database.Esqueleto.Experimental.ToMaybe.ToMaybe a, Database.Esqueleto.Experimental.ToMaybe.ToMaybe b) => Database.Esqueleto.Experimental.ToMaybe.ToMaybe (a, b)
instance (Database.Esqueleto.Experimental.ToMaybe.ToMaybe a, Database.Esqueleto.Experimental.ToMaybe.ToMaybe b, Database.Esqueleto.Experimental.ToMaybe.ToMaybe c) => Database.Esqueleto.Experimental.ToMaybe.ToMaybe (a, b, c)
instance (Database.Esqueleto.Experimental.ToMaybe.ToMaybe a, Database.Esqueleto.Experimental.ToMaybe.ToMaybe b, Database.Esqueleto.Experimental.ToMaybe.ToMaybe c, Database.Esqueleto.Experimental.ToMaybe.ToMaybe d) => Database.Esqueleto.Experimental.ToMaybe.ToMaybe (a, b, c, d)
instance (Database.Esqueleto.Experimental.ToMaybe.ToMaybe a, Database.Esqueleto.Experimental.ToMaybe.ToMaybe b, Database.Esqueleto.Experimental.ToMaybe.ToMaybe c, Database.Esqueleto.Experimental.ToMaybe.ToMaybe d, Database.Esqueleto.Experimental.ToMaybe.ToMaybe e) => Database.Esqueleto.Experimental.ToMaybe.ToMaybe (a, b, c, d, e)
instance (Database.Esqueleto.Experimental.ToMaybe.ToMaybe a, Database.Esqueleto.Experimental.ToMaybe.ToMaybe b, Database.Esqueleto.Experimental.ToMaybe.ToMaybe c, Database.Esqueleto.Experimental.ToMaybe.ToMaybe d, Database.Esqueleto.Experimental.ToMaybe.ToMaybe e, Database.Esqueleto.Experimental.ToMaybe.ToMaybe f) => Database.Esqueleto.Experimental.ToMaybe.ToMaybe (a, b, c, d, e, f)
instance (Database.Esqueleto.Experimental.ToMaybe.ToMaybe a, Database.Esqueleto.Experimental.ToMaybe.ToMaybe b, Database.Esqueleto.Experimental.ToMaybe.ToMaybe c, Database.Esqueleto.Experimental.ToMaybe.ToMaybe d, Database.Esqueleto.Experimental.ToMaybe.ToMaybe e, Database.Esqueleto.Experimental.ToMaybe.ToMaybe f, Database.Esqueleto.Experimental.ToMaybe.ToMaybe g) => Database.Esqueleto.Experimental.ToMaybe.ToMaybe (a, b, c, d, e, f, g)
instance (Database.Esqueleto.Experimental.ToMaybe.ToMaybe a, Database.Esqueleto.Experimental.ToMaybe.ToMaybe b, Database.Esqueleto.Experimental.ToMaybe.ToMaybe c, Database.Esqueleto.Experimental.ToMaybe.ToMaybe d, Database.Esqueleto.Experimental.ToMaybe.ToMaybe e, Database.Esqueleto.Experimental.ToMaybe.ToMaybe f, Database.Esqueleto.Experimental.ToMaybe.ToMaybe g, Database.Esqueleto.Experimental.ToMaybe.ToMaybe h) => Database.Esqueleto.Experimental.ToMaybe.ToMaybe (a, b, c, d, e, f, g, h)

module Database.Esqueleto.Experimental.ToAliasReference
class ToAliasReference a
toAliasReference :: ToAliasReference a => Ident -> a -> SqlQuery a
instance Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Esqueleto.Internal.Internal.Value a))
instance Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Persist.Class.PersistEntity.Entity a))
instance Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (Database.Esqueleto.Internal.Internal.SqlExpr (GHC.Internal.Maybe.Maybe (Database.Persist.Class.PersistEntity.Entity a)))
instance (Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference c, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference d, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference e, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference f, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference g, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference h, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference i, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference j) => Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (a, b, c, d, e, f, g, h, i, j)
instance (Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference c, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference d, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference e, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference f, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference g, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference h, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference i, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference j, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference k) => Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (a, b, c, d, e, f, g, h, i, j, k)
instance (Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference c, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference d, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference e, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference f, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference g, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference h, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference i, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference j, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference k, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference l) => Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (a, b, c, d, e, f, g, h, i, j, k, l)
instance (Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference c, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference d, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference e, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference f, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference g, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference h, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference i, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference j, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference k, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference l, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference m) => Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (a, b, c, d, e, f, g, h, i, j, k, l, m)
instance (Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference c, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference d, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference e, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference f, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference g, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference h, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference i, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference j, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference k, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference l, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference m, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference n) => Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
instance (Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference c, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference d, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference e, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference f, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference g, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference h, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference i, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference j, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference k, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference l, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference m, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference n, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference o) => Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
instance (Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference c, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference d, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference e, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference f, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference g, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference h, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference i, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference j, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference k, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference l, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference m, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference n, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference o, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference p) => Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
instance (Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b) => Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (a, b)
instance (Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference c) => Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (a, b, c)
instance (Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference c, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference d) => Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (a, b, c, d)
instance (Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference c, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference d, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference e) => Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (a, b, c, d, e)
instance (Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference c, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference d, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference e, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference f) => Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (a, b, c, d, e, f)
instance (Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference c, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference d, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference e, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference f, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference g) => Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (a, b, c, d, e, f, g)
instance (Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference c, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference d, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference e, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference f, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference g, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference h) => Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (a, b, c, d, e, f, g, h)
instance (Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference c, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference d, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference e, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference f, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference g, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference h, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference i) => Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (a, b, c, d, e, f, g, h, i)

module Database.Esqueleto.Experimental.ToAlias
class ToAlias a
toAlias :: ToAlias a => a -> SqlQuery a
instance Database.Esqueleto.Experimental.ToAlias.ToAlias (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Esqueleto.Internal.Internal.Value a))
instance Database.Esqueleto.Experimental.ToAlias.ToAlias (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Persist.Class.PersistEntity.Entity a))
instance Database.Esqueleto.Experimental.ToAlias.ToAlias (Database.Esqueleto.Internal.Internal.SqlExpr (GHC.Internal.Maybe.Maybe (Database.Persist.Class.PersistEntity.Entity a)))
instance (Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAlias.ToAlias b, Database.Esqueleto.Experimental.ToAlias.ToAlias c, Database.Esqueleto.Experimental.ToAlias.ToAlias d, Database.Esqueleto.Experimental.ToAlias.ToAlias e, Database.Esqueleto.Experimental.ToAlias.ToAlias f, Database.Esqueleto.Experimental.ToAlias.ToAlias g, Database.Esqueleto.Experimental.ToAlias.ToAlias h, Database.Esqueleto.Experimental.ToAlias.ToAlias i, Database.Esqueleto.Experimental.ToAlias.ToAlias j) => Database.Esqueleto.Experimental.ToAlias.ToAlias (a, b, c, d, e, f, g, h, i, j)
instance (Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAlias.ToAlias b, Database.Esqueleto.Experimental.ToAlias.ToAlias c, Database.Esqueleto.Experimental.ToAlias.ToAlias d, Database.Esqueleto.Experimental.ToAlias.ToAlias e, Database.Esqueleto.Experimental.ToAlias.ToAlias f, Database.Esqueleto.Experimental.ToAlias.ToAlias g, Database.Esqueleto.Experimental.ToAlias.ToAlias h, Database.Esqueleto.Experimental.ToAlias.ToAlias i, Database.Esqueleto.Experimental.ToAlias.ToAlias j, Database.Esqueleto.Experimental.ToAlias.ToAlias k) => Database.Esqueleto.Experimental.ToAlias.ToAlias (a, b, c, d, e, f, g, h, i, j, k)
instance (Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAlias.ToAlias b, Database.Esqueleto.Experimental.ToAlias.ToAlias c, Database.Esqueleto.Experimental.ToAlias.ToAlias d, Database.Esqueleto.Experimental.ToAlias.ToAlias e, Database.Esqueleto.Experimental.ToAlias.ToAlias f, Database.Esqueleto.Experimental.ToAlias.ToAlias g, Database.Esqueleto.Experimental.ToAlias.ToAlias h, Database.Esqueleto.Experimental.ToAlias.ToAlias i, Database.Esqueleto.Experimental.ToAlias.ToAlias j, Database.Esqueleto.Experimental.ToAlias.ToAlias k, Database.Esqueleto.Experimental.ToAlias.ToAlias l) => Database.Esqueleto.Experimental.ToAlias.ToAlias (a, b, c, d, e, f, g, h, i, j, k, l)
instance (Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAlias.ToAlias b, Database.Esqueleto.Experimental.ToAlias.ToAlias c, Database.Esqueleto.Experimental.ToAlias.ToAlias d, Database.Esqueleto.Experimental.ToAlias.ToAlias e, Database.Esqueleto.Experimental.ToAlias.ToAlias f, Database.Esqueleto.Experimental.ToAlias.ToAlias g, Database.Esqueleto.Experimental.ToAlias.ToAlias h, Database.Esqueleto.Experimental.ToAlias.ToAlias i, Database.Esqueleto.Experimental.ToAlias.ToAlias j, Database.Esqueleto.Experimental.ToAlias.ToAlias k, Database.Esqueleto.Experimental.ToAlias.ToAlias l, Database.Esqueleto.Experimental.ToAlias.ToAlias m) => Database.Esqueleto.Experimental.ToAlias.ToAlias (a, b, c, d, e, f, g, h, i, j, k, l, m)
instance (Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAlias.ToAlias b, Database.Esqueleto.Experimental.ToAlias.ToAlias c, Database.Esqueleto.Experimental.ToAlias.ToAlias d, Database.Esqueleto.Experimental.ToAlias.ToAlias e, Database.Esqueleto.Experimental.ToAlias.ToAlias f, Database.Esqueleto.Experimental.ToAlias.ToAlias g, Database.Esqueleto.Experimental.ToAlias.ToAlias h, Database.Esqueleto.Experimental.ToAlias.ToAlias i, Database.Esqueleto.Experimental.ToAlias.ToAlias j, Database.Esqueleto.Experimental.ToAlias.ToAlias k, Database.Esqueleto.Experimental.ToAlias.ToAlias l, Database.Esqueleto.Experimental.ToAlias.ToAlias m, Database.Esqueleto.Experimental.ToAlias.ToAlias n) => Database.Esqueleto.Experimental.ToAlias.ToAlias (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
instance (Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAlias.ToAlias b, Database.Esqueleto.Experimental.ToAlias.ToAlias c, Database.Esqueleto.Experimental.ToAlias.ToAlias d, Database.Esqueleto.Experimental.ToAlias.ToAlias e, Database.Esqueleto.Experimental.ToAlias.ToAlias f, Database.Esqueleto.Experimental.ToAlias.ToAlias g, Database.Esqueleto.Experimental.ToAlias.ToAlias h, Database.Esqueleto.Experimental.ToAlias.ToAlias i, Database.Esqueleto.Experimental.ToAlias.ToAlias j, Database.Esqueleto.Experimental.ToAlias.ToAlias k, Database.Esqueleto.Experimental.ToAlias.ToAlias l, Database.Esqueleto.Experimental.ToAlias.ToAlias m, Database.Esqueleto.Experimental.ToAlias.ToAlias n, Database.Esqueleto.Experimental.ToAlias.ToAlias o) => Database.Esqueleto.Experimental.ToAlias.ToAlias (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
instance (Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAlias.ToAlias b, Database.Esqueleto.Experimental.ToAlias.ToAlias c, Database.Esqueleto.Experimental.ToAlias.ToAlias d, Database.Esqueleto.Experimental.ToAlias.ToAlias e, Database.Esqueleto.Experimental.ToAlias.ToAlias f, Database.Esqueleto.Experimental.ToAlias.ToAlias g, Database.Esqueleto.Experimental.ToAlias.ToAlias h, Database.Esqueleto.Experimental.ToAlias.ToAlias i, Database.Esqueleto.Experimental.ToAlias.ToAlias j, Database.Esqueleto.Experimental.ToAlias.ToAlias k, Database.Esqueleto.Experimental.ToAlias.ToAlias l, Database.Esqueleto.Experimental.ToAlias.ToAlias m, Database.Esqueleto.Experimental.ToAlias.ToAlias n, Database.Esqueleto.Experimental.ToAlias.ToAlias o, Database.Esqueleto.Experimental.ToAlias.ToAlias p) => Database.Esqueleto.Experimental.ToAlias.ToAlias (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
instance (Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAlias.ToAlias b) => Database.Esqueleto.Experimental.ToAlias.ToAlias (a, b)
instance (Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAlias.ToAlias b, Database.Esqueleto.Experimental.ToAlias.ToAlias c) => Database.Esqueleto.Experimental.ToAlias.ToAlias (a, b, c)
instance (Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAlias.ToAlias b, Database.Esqueleto.Experimental.ToAlias.ToAlias c, Database.Esqueleto.Experimental.ToAlias.ToAlias d) => Database.Esqueleto.Experimental.ToAlias.ToAlias (a, b, c, d)
instance (Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAlias.ToAlias b, Database.Esqueleto.Experimental.ToAlias.ToAlias c, Database.Esqueleto.Experimental.ToAlias.ToAlias d, Database.Esqueleto.Experimental.ToAlias.ToAlias e) => Database.Esqueleto.Experimental.ToAlias.ToAlias (a, b, c, d, e)
instance (Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAlias.ToAlias b, Database.Esqueleto.Experimental.ToAlias.ToAlias c, Database.Esqueleto.Experimental.ToAlias.ToAlias d, Database.Esqueleto.Experimental.ToAlias.ToAlias e, Database.Esqueleto.Experimental.ToAlias.ToAlias f) => Database.Esqueleto.Experimental.ToAlias.ToAlias (a, b, c, d, e, f)
instance (Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAlias.ToAlias b, Database.Esqueleto.Experimental.ToAlias.ToAlias c, Database.Esqueleto.Experimental.ToAlias.ToAlias d, Database.Esqueleto.Experimental.ToAlias.ToAlias e, Database.Esqueleto.Experimental.ToAlias.ToAlias f, Database.Esqueleto.Experimental.ToAlias.ToAlias g) => Database.Esqueleto.Experimental.ToAlias.ToAlias (a, b, c, d, e, f, g)
instance (Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAlias.ToAlias b, Database.Esqueleto.Experimental.ToAlias.ToAlias c, Database.Esqueleto.Experimental.ToAlias.ToAlias d, Database.Esqueleto.Experimental.ToAlias.ToAlias e, Database.Esqueleto.Experimental.ToAlias.ToAlias f, Database.Esqueleto.Experimental.ToAlias.ToAlias g, Database.Esqueleto.Experimental.ToAlias.ToAlias h) => Database.Esqueleto.Experimental.ToAlias.ToAlias (a, b, c, d, e, f, g, h)
instance (Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAlias.ToAlias b, Database.Esqueleto.Experimental.ToAlias.ToAlias c, Database.Esqueleto.Experimental.ToAlias.ToAlias d, Database.Esqueleto.Experimental.ToAlias.ToAlias e, Database.Esqueleto.Experimental.ToAlias.ToAlias f, Database.Esqueleto.Experimental.ToAlias.ToAlias g, Database.Esqueleto.Experimental.ToAlias.ToAlias h, Database.Esqueleto.Experimental.ToAlias.ToAlias i) => Database.Esqueleto.Experimental.ToAlias.ToAlias (a, b, c, d, e, f, g, h, i)

module Database.Esqueleto.Experimental.From

-- | FROM clause, used to bring entities into scope.
--   
--   Internally, this function uses the From datatype. Unlike the
--   old from, this does not take a function as a parameter, but
--   rather a value that represents a JOIN tree constructed out of
--   instances of From. This implementation eliminates certain types
--   of runtime errors by preventing the construction of invalid SQL (e.g.
--   illegal nested-from).
from :: ToFrom a a' => a -> SqlQuery a'
type RawFn = NeedParens -> IdentInfo -> (Builder, [PersistValue])

-- | Data type defining the From language. This should not
--   constructed directly in application code.
--   
--   A From is a SqlQuery which returns a reference to the result
--   of calling from and a function that produces a portion of a FROM
--   clause. This gets passed to the FromRaw FromClause constructor
--   directly when converting from a From to a SqlQuery
--   using from
newtype From a
From :: SqlQuery (a, RawFn) -> From a
[unFrom] :: From a -> SqlQuery (a, RawFn)

-- | A helper class primarily designed to allow using SqlQuery
--   directly in a From expression. This is also useful for embedding a
--   SqlSetOperation, as well as supporting backwards
--   compatibility for the data constructor join tree used prior to
--   3.5.0.0
class ToFrom a r | a -> r
toFrom :: ToFrom a r => a -> From r

-- | Deprecated: @since 3.5.0.0 - use table instead
data Table a

-- | Deprecated: @since 3.5.0.0 - use table instead
Table :: Table a

-- | Bring a PersistEntity into scope from a table
--   
--   
--   select $ from $ table @People
--   
table :: PersistEntity ent => From (SqlExpr (Entity ent))

-- | Select from a subquery, often used in conjuction with joins but can be
--   used without any joins. Because SqlQuery has a
--   ToFrom instance you probably dont need to use this function
--   directly.
--   
--   
--   select $
--        p <- from $
--                selectQuery do
--                p <- from $ table @Person
--                limit 5
--                orderBy [ asc p ^. PersonAge ]
--        ...
--   
selectQuery :: (SqlSelect a r, ToAlias a, ToAliasReference a) => SqlQuery a -> From a
instance Database.Esqueleto.Experimental.From.ToFrom (Database.Esqueleto.Experimental.From.From a) a
instance (Database.Esqueleto.Internal.Internal.SqlSelect a r, Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a) => Database.Esqueleto.Experimental.From.ToFrom (Database.Esqueleto.Internal.Internal.SqlQuery a) a
instance Database.Persist.Class.PersistEntity.PersistEntity ent => Database.Esqueleto.Experimental.From.ToFrom (Database.Esqueleto.Experimental.From.Table ent) (Database.Esqueleto.Internal.Internal.SqlExpr (Database.Persist.Class.PersistEntity.Entity ent))

module Database.Esqueleto.Experimental.From.SqlSetOperation

-- | Data type used to implement the SqlSetOperation language this type is
--   implemented in the same way as a From
--   
--   Semantically a SqlSetOperation is always a From but
--   not vice versa
newtype SqlSetOperation a
SqlSetOperation :: (NeedParens -> SqlQuery (a, IdentInfo -> (Builder, [PersistValue]))) -> SqlSetOperation a
[unSqlSetOperation] :: SqlSetOperation a -> NeedParens -> SqlQuery (a, IdentInfo -> (Builder, [PersistValue]))

-- | Type class to support direct use of SqlQuery in a set
--   operation tree
class ToSqlSetOperation a r | a -> r
toSqlSetOperation :: ToSqlSetOperation a r => a -> SqlSetOperation r

-- | Helper function for defining set operations @since 3.5.0.0
mkSetOperation :: (ToSqlSetOperation a a', ToSqlSetOperation b a') => Builder -> a -> b -> SqlSetOperation a'

-- | Overloaded union_ function to support use in both
--   SqlSetOperation and withRecursive
class Union_ a

-- | UNION SQL set operation. Can be used as an infix function
--   between SqlQuery values.
union_ :: Union_ a => a

-- | Overloaded unionAll_ function to support use in both
--   SqlSetOperation and withRecursive
class UnionAll_ a

-- | UNION ALL SQL set operation. Can be used as an infix
--   function between SqlQuery values.
unionAll_ :: UnionAll_ a => a

-- | EXCEPT SQL set operation. Can be used as an infix function
--   between SqlQuery values.
except_ :: (ToSqlSetOperation a a', ToSqlSetOperation b a') => a -> b -> SqlSetOperation a'

-- | INTERSECT SQL set operation. Can be used as an infix function
--   between SqlQuery values.
intersect_ :: (ToSqlSetOperation a a', ToSqlSetOperation b a') => a -> b -> SqlSetOperation a'
instance Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a => Database.Esqueleto.Experimental.From.ToFrom (Database.Esqueleto.Experimental.From.SqlSetOperation.SqlSetOperation a) a
instance (Database.Esqueleto.Internal.Internal.SqlSelect a r, Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a) => Database.Esqueleto.Experimental.From.SqlSetOperation.ToSqlSetOperation (Database.Esqueleto.Internal.Internal.SqlQuery a) a
instance Database.Esqueleto.Experimental.From.SqlSetOperation.ToSqlSetOperation (Database.Esqueleto.Experimental.From.SqlSetOperation.SqlSetOperation a) a
instance (Database.Esqueleto.Experimental.From.SqlSetOperation.ToSqlSetOperation a c, Database.Esqueleto.Experimental.From.SqlSetOperation.ToSqlSetOperation b c, res GHC.Types.~ Database.Esqueleto.Experimental.From.SqlSetOperation.SqlSetOperation c) => Database.Esqueleto.Experimental.From.SqlSetOperation.UnionAll_ (a -> b -> res)
instance (Database.Esqueleto.Experimental.From.SqlSetOperation.ToSqlSetOperation a c, Database.Esqueleto.Experimental.From.SqlSetOperation.ToSqlSetOperation b c, res GHC.Types.~ Database.Esqueleto.Experimental.From.SqlSetOperation.SqlSetOperation c) => Database.Esqueleto.Experimental.From.SqlSetOperation.Union_ (a -> b -> res)

module Database.Esqueleto.Experimental.From.Join

-- | A left-precedence pair. Pronounced "and". Used to represent
--   expressions that have been joined together.
--   
--   The precedence behavior can be demonstrated by:
--   
--   
--   a :& b :& c == ((a :& b) :& c)
--   
--   
--   See the examples at the beginning of this module to see how this
--   operator is used in JOIN operations.
data a :& b
(:&) :: a -> b -> (:&) a b
infixl 2 :&
infixl 2 :&
class ValidOnClause a

-- | An ON clause that describes how two tables are related. This
--   should be used as an infix operator after a JOIN. For
--   example,
--   
--   
--   select $
--   from $ table @Person
--   `innerJoin` table @BlogPost
--   `on` (\(p :& bP) ->
--           p ^. PersonId ==. bP ^. BlogPostAuthorId)
--   
on :: ValidOnClause a => a -> (b -> SqlExpr (Value Bool)) -> (a, b -> SqlExpr (Value Bool))
infix 9 `on`
type family ErrorOnLateral a
fromJoin :: Builder -> RawFn -> RawFn -> Maybe (SqlExpr (Value Bool)) -> RawFn
type family HasOnClause actual expected

-- | INNER JOIN
--   
--   Used as an infix operator `innerJoin`
--   
--   
--   select $
--   from $ table @Person
--   `innerJoin` table @BlogPost
--   `on` (\(p :& bp) ->
--           p ^. PersonId ==. bp ^. BlogPostAuthorId)
--   
innerJoin :: (ToFrom a a', ToFrom b b', HasOnClause rhs (a' :& b'), rhs ~ (b, (a' :& b') -> SqlExpr (Value Bool))) => a -> rhs -> From (a' :& b')
infixl 2 `innerJoin`

-- | INNER JOIN LATERAL
--   
--   A Lateral subquery join allows the joined query to reference entities
--   from the left hand side of the join. Discards rows that don't match
--   the on clause
--   
--   Used as an infix operator `innerJoinLateral`
--   
--   See example 6
innerJoinLateral :: (ToFrom a a', HasOnClause rhs (a' :& b), SqlSelect b r, ToAlias b, ToAliasReference b, rhs ~ (a' -> SqlQuery b, (a' :& b) -> SqlExpr (Value Bool))) => a -> rhs -> From (a' :& b)
infixl 2 `innerJoinLateral`

-- | CROSS JOIN
--   
--   Used as an infix `crossJoin`
--   
--   
--   select $ do
--   from $ table @Person
--   `crossJoin` table @BlogPost
--   
crossJoin :: (ToFrom a a', ToFrom b b') => a -> b -> From (a' :& b')
infixl 2 `crossJoin`

-- | CROSS JOIN LATERAL
--   
--   A Lateral subquery join allows the joined query to reference entities
--   from the left hand side of the join.
--   
--   Used as an infix operator `crossJoinLateral`
--   
--   See example 6
crossJoinLateral :: (ToFrom a a', SqlSelect b r, ToAlias b, ToAliasReference b) => a -> (a' -> SqlQuery b) -> From (a' :& b)
infixl 2 `crossJoinLateral`

-- | LEFT OUTER JOIN
--   
--   Join where the right side may not exist. If the on clause fails then
--   the right side will be NULL'ed Because of this the right side needs to
--   be handled as a Maybe
--   
--   Used as an infix operator `leftJoin`
--   
--   
--   select $
--   from $ table @Person
--   `leftJoin` table @BlogPost
--   `on` (\(p :& bp) ->
--           just (p ^. PersonId) ==. bp ?. BlogPostAuthorId)
--   
leftJoin :: (ToFrom a a', ToFrom b b', ToMaybe b', HasOnClause rhs (a' :& ToMaybeT b'), rhs ~ (b, (a' :& ToMaybeT b') -> SqlExpr (Value Bool))) => a -> rhs -> From (a' :& ToMaybeT b')
infixl 2 `leftJoin`

-- | LEFT OUTER JOIN LATERAL
--   
--   Lateral join where the right side may not exist. In the case that the
--   query returns nothing or the on clause fails the right side of the
--   join will be NULL'ed Because of this the right side needs to be
--   handled as a Maybe
--   
--   Used as an infix operator `leftJoinLateral`
--   
--   See example 6 for how to use LATERAL
leftJoinLateral :: (ToFrom a a', SqlSelect b r, HasOnClause rhs (a' :& ToMaybeT b), ToAlias b, ToAliasReference b, ToMaybe b, rhs ~ (a' -> SqlQuery b, (a' :& ToMaybeT b) -> SqlExpr (Value Bool))) => a -> rhs -> From (a' :& ToMaybeT b)
infixl 2 `leftJoinLateral`

-- | RIGHT OUTER JOIN
--   
--   Join where the left side may not exist. If the on clause fails then
--   the left side will be NULL'ed Because of this the left side needs to
--   be handled as a Maybe
--   
--   Used as an infix operator `rightJoin`
--   
--   
--   select $
--   from $ table @Person
--   `rightJoin` table @BlogPost
--   `on` (\(p :& bp) ->
--           p ?. PersonId ==. bp ^. BlogPostAuthorId)
--   
rightJoin :: (ToFrom a a', ToFrom b b', ToMaybe a', HasOnClause rhs (ToMaybeT a' :& b'), rhs ~ (b, (ToMaybeT a' :& b') -> SqlExpr (Value Bool))) => a -> rhs -> From (ToMaybeT a' :& b')
infixl 2 `rightJoin`

-- | FULL OUTER JOIN
--   
--   Join where both sides of the join may not exist. Because of this the
--   result needs to be handled as a Maybe
--   
--   Used as an infix operator `fullOuterJoin`
--   
--   
--   select $
--   from $ table @Person
--   `fullOuterJoin` table @BlogPost
--   `on` (\(p :& bp) ->
--           p ?. PersonId ==. bp ?. BlogPostAuthorId)
--   
fullOuterJoin :: (ToFrom a a', ToFrom b b', ToMaybe a', ToMaybe b', HasOnClause rhs (ToMaybeT a' :& ToMaybeT b'), rhs ~ (b, (ToMaybeT a' :& ToMaybeT b') -> SqlExpr (Value Bool))) => a -> rhs -> From (ToMaybeT a' :& ToMaybeT b')
infixl 2 `fullOuterJoin`

-- | Typeclass for selecting tables using type application syntax.
--   
--   If you have a long chain of tables joined with (:&), like
--   a :& b :& c :& d, then getTable @c (a :&
--   b :& c :& d) will give you the c table back.
--   
--   Note that this typeclass will only select the first table of the given
--   type; it may be less useful if there's multiple tables of the same
--   type.
class GetFirstTable t ts

-- | Get the first table of type t from the tables ts.
getFirstTable :: GetFirstTable t ts => ts -> t

-- | Get the first table of a given type from a chain of tables joined with
--   (:&).
--   
--   This can make it easier to write queries with a large number of join
--   clauses:
--   
--   
--   select $ do
--   (people :& followers :& blogPosts) <-
--       from $ table @Person
--       `innerJoin` table @Follow
--       `on` (\(person :& follow) ->
--               person ^. PersonId ==. follow ^. FollowFollowed)
--       `innerJoin` table @BlogPost
--       `on` (\((getTable @Follow -> follow) :& blogPost) ->
--               blogPost ^. BlogPostAuthorId ==. follow ^. FollowFollower)
--   where_ (people1 ^. PersonName ==. val "John")
--   pure (followers, people2)
--   
--   
--   This example is a bit trivial, but once you've joined five or six
--   tables it becomes enormously helpful. The above example uses a
--   ViewPattern to call the function and assign the variable
--   directly, but you can also imagine it being written like this:
--   
--   
--   `on` (\(prev :& blogPost) ->
--           let
--               follow = getTable @Follow prev
--            in
--               blogPost ^. BlogPostAuthorId ==. follow ^. FollowFollower)
--   
--   
--   This function will pluck out the first table that matches the applied
--   type, so if you join on the same table multiple times, it will always
--   select the first one provided.
--   
--   The (:&) operator associates so that the left hand side can
--   be a wildcard for an arbitrary amount of nesting, and the "most
--   recent" or "newest" table in a join sequence is always available on
--   the rightmost - so (prev :& bar) is a pattern that
--   matches bar table (the most recent table added) and
--   prev tables (all prior tables in the join match).
--   
--   By calling getTable on the prev, you can select
--   exactly the table you want, allowing you to omit a large number of
--   spurious pattern matches. Consider a query that does several LEFT
--   JOIN on a first table:
--   
--   
--   SELECT *
--   FROM person
--   LEFT JOIN car
--     ON person.id = car.person_id
--   LEFT JOIN bike
--     ON person.id = bike.person_id
--   LEFT JOIN food
--     ON person.id = food.person_id
--   LEFT JOIN address
--     ON person.id = address.person_id
--   
--   
--   The final on clause in esqueleto would look like this:
--   
--   
--   `on` do
--       \(person :& _car :& _bike :& _food :& address) ->
--           person.id ==. address.personId
--   
--   
--   First, we can change it to a prev :& newest match. We can
--   do this because of the operator associativity. This is kind of like
--   how a list : operator associates, but in the other direction:
--   a : (b : c) = a : b : c.
--   
--   
--   `on` do
--       \(prev :& address) ->
--           let (person :& _car :& _bike :& _food) = prev
--            in person.id ==. address.personId
--   
--   
--   Then, we can use getTable to select the Person table
--   directly, instead of pattern matching manually.
--   
--   
--   `on` do
--       \(prev :& address) ->
--           let person = getTable @Person prev
--            in person.id ==. address.personId
--   
--   
--   Finally, we can use a ViewPattern language extension to
--   "inline" the access.
--   
--   
--   `on` do
--       \((getTable @Person -> person) :& address) ->
--          person.id ==. address.personId
--   
--   
--   With this form, you do not need to be concerned about the number and
--   wildcard status of tables that do not matter to the specific
--   ON clause.
getTable :: GetFirstTable (SqlExpr (Entity t)) ts => ts -> SqlExpr (Entity t)

-- | A variant of getTable that operates on possibly-null entities.
getTableMaybe :: GetFirstTable (SqlExpr (Maybe (Entity t))) ts => ts -> SqlExpr (Maybe (Entity t))
data Lateral
data NotLateral
type family IsLateral a
class DoInnerJoin lateral lhs rhs res | lateral rhs lhs -> res
doInnerJoin :: DoInnerJoin lateral lhs rhs res => Proxy lateral -> lhs -> rhs -> From res
class DoLeftJoin lateral lhs rhs res | lateral rhs lhs -> res
doLeftJoin :: DoLeftJoin lateral lhs rhs res => Proxy lateral -> lhs -> rhs -> From res
class DoCrossJoin lateral lhs rhs res | lateral lhs rhs -> res
doCrossJoin :: DoCrossJoin lateral lhs rhs res => Proxy lateral -> lhs -> rhs -> From res
instance (Database.Esqueleto.Experimental.From.ToFrom a a', Database.Esqueleto.Internal.Internal.SqlSelect b r, Database.Esqueleto.Experimental.ToAlias.ToAlias b, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b) => Database.Esqueleto.Experimental.From.Join.DoCrossJoin Database.Esqueleto.Experimental.From.Join.Lateral a (a' -> Database.Esqueleto.Internal.Internal.SqlQuery b) (a' Database.Esqueleto.Internal.Internal.:& b)
instance (Database.Esqueleto.Experimental.From.ToFrom a a', Database.Esqueleto.Experimental.From.ToFrom b b') => Database.Esqueleto.Experimental.From.Join.DoCrossJoin Database.Esqueleto.Experimental.From.Join.NotLateral a b (a' Database.Esqueleto.Internal.Internal.:& b')
instance (Database.Esqueleto.Experimental.From.ToFrom a a', Database.Esqueleto.Internal.Internal.SqlSelect b r, Database.Esqueleto.Experimental.ToAlias.ToAlias b, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b, d GHC.Types.~ (a' Database.Esqueleto.Internal.Internal.:& b)) => Database.Esqueleto.Experimental.From.Join.DoInnerJoin Database.Esqueleto.Experimental.From.Join.Lateral a (a' -> Database.Esqueleto.Internal.Internal.SqlQuery b, d -> Database.Esqueleto.Internal.Internal.SqlExpr (Database.Esqueleto.Internal.Internal.Value GHC.Types.Bool)) d
instance (Database.Esqueleto.Experimental.From.ToFrom a a', Database.Esqueleto.Experimental.From.ToFrom b b', Database.Esqueleto.Experimental.From.Join.HasOnClause rhs (a' Database.Esqueleto.Internal.Internal.:& b'), rhs GHC.Types.~ (b, (a' Database.Esqueleto.Internal.Internal.:& b') -> Database.Esqueleto.Internal.Internal.SqlExpr (Database.Esqueleto.Internal.Internal.Value GHC.Types.Bool))) => Database.Esqueleto.Experimental.From.Join.DoInnerJoin Database.Esqueleto.Experimental.From.Join.NotLateral a rhs (a' Database.Esqueleto.Internal.Internal.:& b')
instance (Database.Esqueleto.Experimental.From.ToFrom a a', Database.Esqueleto.Experimental.ToMaybe.ToMaybe b, d GHC.Types.~ (a' Database.Esqueleto.Internal.Internal.:& Database.Esqueleto.Experimental.ToMaybe.ToMaybeT b), Database.Esqueleto.Internal.Internal.SqlSelect b r, Database.Esqueleto.Experimental.ToAlias.ToAlias b, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b) => Database.Esqueleto.Experimental.From.Join.DoLeftJoin Database.Esqueleto.Experimental.From.Join.Lateral a (a' -> Database.Esqueleto.Internal.Internal.SqlQuery b, d -> Database.Esqueleto.Internal.Internal.SqlExpr (Database.Esqueleto.Internal.Internal.Value GHC.Types.Bool)) d
instance (Database.Esqueleto.Experimental.From.ToFrom a a', Database.Esqueleto.Experimental.From.ToFrom b b', Database.Esqueleto.Experimental.ToMaybe.ToMaybe b', Database.Esqueleto.Experimental.ToMaybe.ToMaybeT b' GHC.Types.~ mb, Database.Esqueleto.Experimental.From.Join.HasOnClause rhs (a' Database.Esqueleto.Internal.Internal.:& mb), rhs GHC.Types.~ (b, (a' Database.Esqueleto.Internal.Internal.:& mb) -> Database.Esqueleto.Internal.Internal.SqlExpr (Database.Esqueleto.Internal.Internal.Value GHC.Types.Bool))) => Database.Esqueleto.Experimental.From.Join.DoLeftJoin Database.Esqueleto.Experimental.From.Join.NotLateral a rhs (a' Database.Esqueleto.Internal.Internal.:& mb)
instance Database.Esqueleto.Experimental.From.Join.GetFirstTable t (t Database.Esqueleto.Internal.Internal.:& ts)
instance Database.Esqueleto.Experimental.From.Join.GetFirstTable t (x Database.Esqueleto.Internal.Internal.:& t)
instance Database.Esqueleto.Experimental.From.Join.GetFirstTable t ts => Database.Esqueleto.Experimental.From.Join.GetFirstTable t (ts Database.Esqueleto.Internal.Internal.:& x)
instance (Database.Esqueleto.Internal.Internal.SqlSelect a ra, Database.Esqueleto.Internal.Internal.SqlSelect b rb) => Database.Esqueleto.Internal.Internal.SqlSelect (a Database.Esqueleto.Internal.Internal.:& b) (ra Database.Esqueleto.Internal.Internal.:& rb)
instance (Database.Esqueleto.Experimental.ToAlias.ToAlias a, Database.Esqueleto.Experimental.ToAlias.ToAlias b) => Database.Esqueleto.Experimental.ToAlias.ToAlias (a Database.Esqueleto.Internal.Internal.:& b)
instance (Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference a, Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference b) => Database.Esqueleto.Experimental.ToAliasReference.ToAliasReference (a Database.Esqueleto.Internal.Internal.:& b)
instance (Database.Esqueleto.Experimental.From.Join.DoCrossJoin lateral lhs rhs r, Database.Esqueleto.Experimental.From.Join.IsLateral rhs GHC.Types.~ lateral) => Database.Esqueleto.Experimental.From.ToFrom (Database.Esqueleto.Internal.Internal.CrossJoin lhs rhs) r
instance (Database.Esqueleto.Experimental.From.ToFrom a a', Database.Esqueleto.Experimental.From.ToFrom b b', Database.Esqueleto.Experimental.ToMaybe.ToMaybe a', Database.Esqueleto.Experimental.ToMaybe.ToMaybeT a' GHC.Types.~ ma, Database.Esqueleto.Experimental.ToMaybe.ToMaybe b', Database.Esqueleto.Experimental.ToMaybe.ToMaybeT b' GHC.Types.~ mb, Database.Esqueleto.Experimental.From.Join.HasOnClause rhs (ma Database.Esqueleto.Internal.Internal.:& mb), Database.Esqueleto.Experimental.From.Join.ErrorOnLateral b, rhs GHC.Types.~ (b, (ma Database.Esqueleto.Internal.Internal.:& mb) -> Database.Esqueleto.Internal.Internal.SqlExpr (Database.Esqueleto.Internal.Internal.Value GHC.Types.Bool))) => Database.Esqueleto.Experimental.From.ToFrom (Database.Esqueleto.Internal.Internal.FullOuterJoin a rhs) (ma Database.Esqueleto.Internal.Internal.:& mb)
instance (Database.Esqueleto.Experimental.From.Join.DoInnerJoin lateral lhs rhs r, lateral GHC.Types.~ Database.Esqueleto.Experimental.From.Join.IsLateral rhs) => Database.Esqueleto.Experimental.From.ToFrom (Database.Esqueleto.Internal.Internal.InnerJoin lhs rhs) r
instance (Database.Esqueleto.Experimental.From.Join.DoLeftJoin lateral lhs rhs r, lateral GHC.Types.~ Database.Esqueleto.Experimental.From.Join.IsLateral rhs) => Database.Esqueleto.Experimental.From.ToFrom (Database.Esqueleto.Internal.Internal.LeftOuterJoin lhs rhs) r
instance (Database.Esqueleto.Experimental.From.ToFrom a a', Database.Esqueleto.Experimental.From.ToFrom b b', Database.Esqueleto.Experimental.ToMaybe.ToMaybe a', Database.Esqueleto.Experimental.ToMaybe.ToMaybeT a' GHC.Types.~ ma, Database.Esqueleto.Experimental.From.Join.HasOnClause rhs (ma Database.Esqueleto.Internal.Internal.:& b'), Database.Esqueleto.Experimental.From.Join.ErrorOnLateral b, rhs GHC.Types.~ (b, (ma Database.Esqueleto.Internal.Internal.:& b') -> Database.Esqueleto.Internal.Internal.SqlExpr (Database.Esqueleto.Internal.Internal.Value GHC.Types.Bool))) => Database.Esqueleto.Experimental.From.ToFrom (Database.Esqueleto.Internal.Internal.RightOuterJoin a rhs) (ma Database.Esqueleto.Internal.Internal.:& b')
instance (Database.Esqueleto.Experimental.ToMaybe.ToMaybe a, Database.Esqueleto.Experimental.ToMaybe.ToMaybe b) => Database.Esqueleto.Experimental.ToMaybe.ToMaybe (a Database.Esqueleto.Internal.Internal.:& b)
instance Database.Esqueleto.Experimental.From.Join.ValidOnClause (a -> Database.Esqueleto.Internal.Internal.SqlQuery b)
instance Database.Esqueleto.Experimental.From.ToFrom a a' => Database.Esqueleto.Experimental.From.Join.ValidOnClause a

module Database.Esqueleto.Experimental.From.CommonTableExpression

-- | WITH clause used to introduce a Common Table Expression
--   (CTE). CTEs are supported in most modern SQL engines and can be
--   useful in performance tuning. In Esqueleto, CTEs should be used as a
--   subquery memoization tactic. When writing plain SQL, CTEs are
--   sometimes used to organize the SQL code, in Esqueleto, this is better
--   achieved through function that return SqlQuery values.
--   
--   
--   select $ do
--   cte <- with subQuery
--   cteResult <- from cte
--   where_ $ cteResult ...
--   pure cteResult
--   
--   
--   WARNING: In some SQL engines using a CTE can diminish
--   performance. In these engines the CTE is treated as an optimization
--   fence. You should always verify that using a CTE will in fact improve
--   your performance over a regular subquery.
--   
--   Notably, in PostgreSQL prior to version 12, CTEs are always fully
--   calculated, which can potentially significantly pessimize queries. As
--   of PostgreSQL 12, non-recursive and side-effect-free queries may be
--   inlined and optimized accordingly if not declared
--   MATERIALIZED to get the previous behaviour. See the
--   PostgreSQL CTE documentation, section Materialization, for more
--   information. To use a MATERIALIZED query in Esquelto, see
--   functions withMaterialized and
--   withRecursiveMaterialized.
--   
--   Since: 3.4.0.0
with :: (ToAlias a, ToAliasReference a, SqlSelect a r) => SqlQuery a -> SqlQuery (From a)

-- | WITH RECURSIVE allows one to make a recursive
--   subquery, which can reference itself. Like WITH, this is
--   supported in most modern SQL engines. Useful for hierarchical,
--   self-referential data, like a tree of data.
--   
--   
--   select $ do
--   cte <- withRecursive
--            (do
--                person <- from $ table @Person
--                where_ $ person ^. PersonId ==. val personId
--                pure person
--            )
--            unionAll_
--            (\self -> do
--                (p :& f :& p2 :& pSelf) <- from self
--                         `innerJoin` $ table @Follow
--                         `on` (\(p :& f) ->
--                                 p ^. PersonId ==. f ^. FollowFollower)
--                         `innerJoin` $ table @Person
--                         `on` (\(p :& f :& p2) ->
--                                 f ^. FollowFollowed ==. p2 ^. PersonId)
--                         `leftJoin` self
--                         `on` (\(_ :& _ :& p2 :& pSelf) ->
--                                 just (p2 ^. PersonId) ==. pSelf ?. PersonId)
--                where_ $ isNothing (pSelf ?. PersonId)
--                groupBy (p2 ^. PersonId)
--                pure p2
--            )
--   from cte
--   
--   
--   Since: 3.4.0.0
withRecursive :: (ToAlias a, ToAliasReference a, SqlSelect a r) => SqlQuery a -> UnionKind -> (From a -> SqlQuery a) -> SqlQuery (From a)
newtype UnionKind
UnionKind :: Builder -> UnionKind
[unUnionKind] :: UnionKind -> Builder
instance Database.Esqueleto.Experimental.From.SqlSetOperation.UnionAll_ Database.Esqueleto.Experimental.From.CommonTableExpression.UnionKind
instance Database.Esqueleto.Experimental.From.SqlSetOperation.Union_ Database.Esqueleto.Experimental.From.CommonTableExpression.UnionKind

-- | This module contains a new way (introduced in 3.3.3.0) of using
--   FROM in Haskell. The old method was a bit finicky and could
--   permit runtime errors, and this new way is both significantly safer
--   and much more powerful.
--   
--   This syntax will become the default syntax exported from the library
--   in version 3.6.0.0. To use the old syntax, see
--   Database.Esqueleto.Legacy.
module Database.Esqueleto.Experimental

-- | FROM clause, used to bring entities into scope.
--   
--   Internally, this function uses the From datatype. Unlike the
--   old from, this does not take a function as a parameter, but
--   rather a value that represents a JOIN tree constructed out of
--   instances of From. This implementation eliminates certain types
--   of runtime errors by preventing the construction of invalid SQL (e.g.
--   illegal nested-from).
from :: ToFrom a a' => a -> SqlQuery a'

-- | Bring a PersistEntity into scope from a table
--   
--   
--   select $ from $ table @People
--   
table :: PersistEntity ent => From (SqlExpr (Entity ent))

-- | Deprecated: @since 3.5.0.0 - use table instead
data Table a

-- | Deprecated: @since 3.5.0.0 - use table instead
Table :: Table a

-- | Select from a subquery, often used in conjuction with joins but can be
--   used without any joins. Because SqlQuery has a
--   ToFrom instance you probably dont need to use this function
--   directly.
--   
--   
--   select $
--        p <- from $
--                selectQuery do
--                p <- from $ table @Person
--                limit 5
--                orderBy [ asc p ^. PersonAge ]
--        ...
--   
selectQuery :: (SqlSelect a r, ToAlias a, ToAliasReference a) => SqlQuery a -> From a

-- | A left-precedence pair. Pronounced "and". Used to represent
--   expressions that have been joined together.
--   
--   The precedence behavior can be demonstrated by:
--   
--   
--   a :& b :& c == ((a :& b) :& c)
--   
--   
--   See the examples at the beginning of this module to see how this
--   operator is used in JOIN operations.
data a :& b
(:&) :: a -> b -> (:&) a b
infixl 2 :&
infixl 2 :&

-- | An ON clause that describes how two tables are related. This
--   should be used as an infix operator after a JOIN. For
--   example,
--   
--   
--   select $
--   from $ table @Person
--   `innerJoin` table @BlogPost
--   `on` (\(p :& bP) ->
--           p ^. PersonId ==. bP ^. BlogPostAuthorId)
--   
on :: ValidOnClause a => a -> (b -> SqlExpr (Value Bool)) -> (a, b -> SqlExpr (Value Bool))
infix 9 `on`

-- | INNER JOIN
--   
--   Used as an infix operator `innerJoin`
--   
--   
--   select $
--   from $ table @Person
--   `innerJoin` table @BlogPost
--   `on` (\(p :& bp) ->
--           p ^. PersonId ==. bp ^. BlogPostAuthorId)
--   
innerJoin :: (ToFrom a a', ToFrom b b', HasOnClause rhs (a' :& b'), rhs ~ (b, (a' :& b') -> SqlExpr (Value Bool))) => a -> rhs -> From (a' :& b')
infixl 2 `innerJoin`

-- | INNER JOIN LATERAL
--   
--   A Lateral subquery join allows the joined query to reference entities
--   from the left hand side of the join. Discards rows that don't match
--   the on clause
--   
--   Used as an infix operator `innerJoinLateral`
--   
--   See example 6
innerJoinLateral :: (ToFrom a a', HasOnClause rhs (a' :& b), SqlSelect b r, ToAlias b, ToAliasReference b, rhs ~ (a' -> SqlQuery b, (a' :& b) -> SqlExpr (Value Bool))) => a -> rhs -> From (a' :& b)
infixl 2 `innerJoinLateral`

-- | LEFT OUTER JOIN
--   
--   Join where the right side may not exist. If the on clause fails then
--   the right side will be NULL'ed Because of this the right side needs to
--   be handled as a Maybe
--   
--   Used as an infix operator `leftJoin`
--   
--   
--   select $
--   from $ table @Person
--   `leftJoin` table @BlogPost
--   `on` (\(p :& bp) ->
--           just (p ^. PersonId) ==. bp ?. BlogPostAuthorId)
--   
leftJoin :: (ToFrom a a', ToFrom b b', ToMaybe b', HasOnClause rhs (a' :& ToMaybeT b'), rhs ~ (b, (a' :& ToMaybeT b') -> SqlExpr (Value Bool))) => a -> rhs -> From (a' :& ToMaybeT b')
infixl 2 `leftJoin`

-- | LEFT OUTER JOIN LATERAL
--   
--   Lateral join where the right side may not exist. In the case that the
--   query returns nothing or the on clause fails the right side of the
--   join will be NULL'ed Because of this the right side needs to be
--   handled as a Maybe
--   
--   Used as an infix operator `leftJoinLateral`
--   
--   See example 6 for how to use LATERAL
leftJoinLateral :: (ToFrom a a', SqlSelect b r, HasOnClause rhs (a' :& ToMaybeT b), ToAlias b, ToAliasReference b, ToMaybe b, rhs ~ (a' -> SqlQuery b, (a' :& ToMaybeT b) -> SqlExpr (Value Bool))) => a -> rhs -> From (a' :& ToMaybeT b)
infixl 2 `leftJoinLateral`

-- | RIGHT OUTER JOIN
--   
--   Join where the left side may not exist. If the on clause fails then
--   the left side will be NULL'ed Because of this the left side needs to
--   be handled as a Maybe
--   
--   Used as an infix operator `rightJoin`
--   
--   
--   select $
--   from $ table @Person
--   `rightJoin` table @BlogPost
--   `on` (\(p :& bp) ->
--           p ?. PersonId ==. bp ^. BlogPostAuthorId)
--   
rightJoin :: (ToFrom a a', ToFrom b b', ToMaybe a', HasOnClause rhs (ToMaybeT a' :& b'), rhs ~ (b, (ToMaybeT a' :& b') -> SqlExpr (Value Bool))) => a -> rhs -> From (ToMaybeT a' :& b')
infixl 2 `rightJoin`

-- | FULL OUTER JOIN
--   
--   Join where both sides of the join may not exist. Because of this the
--   result needs to be handled as a Maybe
--   
--   Used as an infix operator `fullOuterJoin`
--   
--   
--   select $
--   from $ table @Person
--   `fullOuterJoin` table @BlogPost
--   `on` (\(p :& bp) ->
--           p ?. PersonId ==. bp ?. BlogPostAuthorId)
--   
fullOuterJoin :: (ToFrom a a', ToFrom b b', ToMaybe a', ToMaybe b', HasOnClause rhs (ToMaybeT a' :& ToMaybeT b'), rhs ~ (b, (ToMaybeT a' :& ToMaybeT b') -> SqlExpr (Value Bool))) => a -> rhs -> From (ToMaybeT a' :& ToMaybeT b')
infixl 2 `fullOuterJoin`

-- | CROSS JOIN
--   
--   Used as an infix `crossJoin`
--   
--   
--   select $ do
--   from $ table @Person
--   `crossJoin` table @BlogPost
--   
crossJoin :: (ToFrom a a', ToFrom b b') => a -> b -> From (a' :& b')
infixl 2 `crossJoin`

-- | CROSS JOIN LATERAL
--   
--   A Lateral subquery join allows the joined query to reference entities
--   from the left hand side of the join.
--   
--   Used as an infix operator `crossJoinLateral`
--   
--   See example 6
crossJoinLateral :: (ToFrom a a', SqlSelect b r, ToAlias b, ToAliasReference b) => a -> (a' -> SqlQuery b) -> From (a' :& b)
infixl 2 `crossJoinLateral`

-- | UNION SQL set operation. Can be used as an infix function
--   between SqlQuery values.
union_ :: Union_ a => a

-- | UNION ALL SQL set operation. Can be used as an infix
--   function between SqlQuery values.
unionAll_ :: UnionAll_ a => a

-- | EXCEPT SQL set operation. Can be used as an infix function
--   between SqlQuery values.
except_ :: (ToSqlSetOperation a a', ToSqlSetOperation b a') => a -> b -> SqlSetOperation a'

-- | INTERSECT SQL set operation. Can be used as an infix function
--   between SqlQuery values.
intersect_ :: (ToSqlSetOperation a a', ToSqlSetOperation b a') => a -> b -> SqlSetOperation a'

-- | WITH clause used to introduce a Common Table Expression
--   (CTE). CTEs are supported in most modern SQL engines and can be
--   useful in performance tuning. In Esqueleto, CTEs should be used as a
--   subquery memoization tactic. When writing plain SQL, CTEs are
--   sometimes used to organize the SQL code, in Esqueleto, this is better
--   achieved through function that return SqlQuery values.
--   
--   
--   select $ do
--   cte <- with subQuery
--   cteResult <- from cte
--   where_ $ cteResult ...
--   pure cteResult
--   
--   
--   WARNING: In some SQL engines using a CTE can diminish
--   performance. In these engines the CTE is treated as an optimization
--   fence. You should always verify that using a CTE will in fact improve
--   your performance over a regular subquery.
--   
--   Notably, in PostgreSQL prior to version 12, CTEs are always fully
--   calculated, which can potentially significantly pessimize queries. As
--   of PostgreSQL 12, non-recursive and side-effect-free queries may be
--   inlined and optimized accordingly if not declared
--   MATERIALIZED to get the previous behaviour. See the
--   PostgreSQL CTE documentation, section Materialization, for more
--   information. To use a MATERIALIZED query in Esquelto, see
--   functions withMaterialized and
--   withRecursiveMaterialized.
--   
--   Since: 3.4.0.0
with :: (ToAlias a, ToAliasReference a, SqlSelect a r) => SqlQuery a -> SqlQuery (From a)

-- | WITH RECURSIVE allows one to make a recursive
--   subquery, which can reference itself. Like WITH, this is
--   supported in most modern SQL engines. Useful for hierarchical,
--   self-referential data, like a tree of data.
--   
--   
--   select $ do
--   cte <- withRecursive
--            (do
--                person <- from $ table @Person
--                where_ $ person ^. PersonId ==. val personId
--                pure person
--            )
--            unionAll_
--            (\self -> do
--                (p :& f :& p2 :& pSelf) <- from self
--                         `innerJoin` $ table @Follow
--                         `on` (\(p :& f) ->
--                                 p ^. PersonId ==. f ^. FollowFollower)
--                         `innerJoin` $ table @Person
--                         `on` (\(p :& f :& p2) ->
--                                 f ^. FollowFollowed ==. p2 ^. PersonId)
--                         `leftJoin` self
--                         `on` (\(_ :& _ :& p2 :& pSelf) ->
--                                 just (p2 ^. PersonId) ==. pSelf ?. PersonId)
--                where_ $ isNothing (pSelf ?. PersonId)
--                groupBy (p2 ^. PersonId)
--                pure p2
--            )
--   from cte
--   
--   
--   Since: 3.4.0.0
withRecursive :: (ToAlias a, ToAliasReference a, SqlSelect a r) => SqlQuery a -> UnionKind -> (From a -> SqlQuery a) -> SqlQuery (From a)

-- | Data type defining the From language. This should not
--   constructed directly in application code.
--   
--   A From is a SqlQuery which returns a reference to the result
--   of calling from and a function that produces a portion of a FROM
--   clause. This gets passed to the FromRaw FromClause constructor
--   directly when converting from a From to a SqlQuery
--   using from
newtype From a
From :: SqlQuery (a, RawFn) -> From a
[unFrom] :: From a -> SqlQuery (a, RawFn)
class ToMaybe a where {
    type ToMaybeT a;
}
toMaybe :: ToMaybe a => a -> ToMaybeT a
class ToAlias a
toAlias :: ToAlias a => a -> SqlQuery a
class ToAliasReference a
toAliasReference :: ToAliasReference a => Ident -> a -> SqlQuery a

-- | Type class to support direct use of SqlQuery in a set
--   operation tree
class ToSqlSetOperation a r | a -> r
toSqlSetOperation :: ToSqlSetOperation a r => a -> SqlSetOperation r

-- | (Internal) Class for mapping results coming from SqlQuery into
--   actual results.
--   
--   This looks very similar to RawSql, and it is! However, there
--   are some crucial differences and ultimately they're different classes.
class SqlSelect a r | a -> r, r -> a
type family Nullable a

-- | WHERE clause: restrict the query's result.
where_ :: SqlExpr (Value Bool) -> SqlQuery ()

-- | GROUP BY clause. You can enclose multiple columns in a tuple.
--   
--   
--   select $ from \(foo `<tt>InnerJoin</tt>` 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 `<tt>InnerJoin</tt>` 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)
--   
groupBy :: ToSomeValues a => a -> SqlQuery ()

-- | An alias for groupBy that avoids conflict with the term from
--   Data.List groupBy.
groupBy_ :: ToSomeValues a => a -> SqlQuery ()

-- | ORDER BY clause. See also asc and desc.
--   
--   Multiple calls to orderBy get concatenated on the final query,
--   including distinctOnOrderBy.
orderBy :: [SqlExpr OrderBy] -> SqlQuery ()

-- | Ascending order of this field or SqlExpression.
asc :: PersistField a => SqlExpr (Value a) -> SqlExpr OrderBy

-- | Descending order of this field or SqlExpression.
desc :: PersistField a => SqlExpr (Value a) -> SqlExpr OrderBy

-- | LIMIT. Limit the number of returned rows.
limit :: Int64 -> SqlQuery ()

-- | OFFSET. Usually used with limit.
offset :: Int64 -> SqlQuery ()

-- | 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 ())
--     ...
--   
distinct :: 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.

-- | Deprecated: This function is deprecated, as it is only supported in
--   Postgresql. Please use the variant in PostgreSQL instead.
distinctOn :: [SqlExpr DistinctOn] -> SqlQuery a -> SqlQuery a

-- | Erase an SqlExpression's type so that it's suitable to be used by
--   distinctOn.
don :: SqlExpr (Value a) -> SqlExpr DistinctOn

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

-- | Deprecated: This function is deprecated, as it is only supported in
--   Postgresql. Please use the function defined in PostgreSQL
--   instead.
distinctOnOrderBy :: [SqlExpr OrderBy] -> SqlQuery a -> SqlQuery a

-- | HAVING.
having :: SqlExpr (Value Bool) -> 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.
locking :: LockingKind -> SqlQuery ()

-- | FOR UPDATE syntax.
--   
--   Usage:
--   
--   
--   locking forUpdate
--   
forUpdate :: LockingKind

-- | FOR UPDATE SKIP LOCKED syntax.
--   
--   
--   locking forUpdateSkipLocked
--   
forUpdateSkipLocked :: LockingKind

-- | Project a field of an entity.
(^.) :: forall typ val. (PersistEntity val, PersistField typ) => SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
infixl 9 ^.

-- | Project an EntityField of a nullable entity. The result type
--   will be Nullable, meaning that nested Maybe won't be
--   produced here.
--   
--   As of v3.6.0.0, this will attempt to combine nested Maybe. If
--   you want to keep nested Maybe, then see ??..
(?.) :: (PersistEntity val, PersistField typ) => SqlExpr (Maybe (Entity val)) -> EntityField val typ -> SqlExpr (Value (Maybe (Nullable typ)))
infixl 9 ?.

-- | Lift a constant value from Haskell-land to the query.
val :: PersistField typ => typ -> SqlExpr (Value typ)

-- | 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:
--   
--   TODO: table
--   
--   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}
--   
isNothing :: PersistField typ => SqlExpr (Value (Maybe typ)) -> SqlExpr (Value Bool)

-- | An alias for isNothing that avoids clashing with the function
--   from Data.Maybe isNothing.
isNothing_ :: PersistField typ => SqlExpr (Value (Maybe typ)) -> SqlExpr (Value Bool)

-- | Analogous to Just, promotes a value of type typ into
--   one of type Maybe typ. It should hold that val .
--   Just === just . val.
--   
--   This function will try not to produce a nested Maybe. This is
--   in accord with how SQL represents NULL. That means that
--   just . just = just. This behavior was
--   changed in v3.6.0.0. If you want to produce nested Maybe, see
--   just'.
just :: NullableFieldProjection typ typ' => SqlExpr (Value typ) -> SqlExpr (Value (Maybe typ'))

-- | NULL value.
nothing :: SqlExpr (Value (Maybe typ))

-- | Join nested Maybes in a Value into one. This is useful
--   when calling aggregate functions on nullable fields.
--   
--   As of v3.6.0.0, this function will attempt to work on both
--   SqlExpr (Value (Maybe a)) as well as
--   SqlExpr (Value (Maybe (Maybe a)))
--   inputs to make transitioning to NullableFieldProjection easier.
--   This may make type inference worse in some cases. If you want the
--   monomorphic variant, see joinV'
joinV :: NullableFieldProjection typ typ' => SqlExpr (Value (Maybe typ)) -> SqlExpr (Value (Maybe typ'))

-- | Project an SqlExpression that may be null, guarding against null
--   cases.
withNonNull :: PersistField typ => SqlExpr (Value (Maybe typ)) -> (SqlExpr (Value typ) -> SqlQuery a) -> SqlQuery a

-- | COUNT(*) value.
countRows :: Num a => SqlExpr (Value a)

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

-- | COUNT(DISTINCT x).
countDistinct :: Num a => SqlExpr (Value typ) -> SqlExpr (Value a)
not_ :: SqlExpr (Value Bool) -> SqlExpr (Value Bool)

-- | This operator produces the SQL operator =, which is used to
--   compare values for equality.
--   
--   Example:
--   
--   
--   query :: UserId -> SqlPersistT IO [Entity User]
--   query userId = select $ do
--       user <- from $ table @User
--       where_ (user ^. UserId ==. val userId)
--       pure user
--   
--   
--   This would generate the following SQL:
--   
--   
--   SELECT user.*
--   FROM user
--   WHERE user.id = ?
--   
(==.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 ==.

-- | This operator translates to the SQL operator >=.
--   
--   Example:
--   
--   
--   where_ $ user ^. UserAge >=. val 21
--   
(>=.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 >=.

-- | This operator translates to the SQL operator >.
--   
--   Example:
--   
--   
--   where_ $ user ^. UserAge >. val 20
--   
(>.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 >.

-- | This operator translates to the SQL operator <=.
--   
--   Example:
--   
--   
--   where_ $ val 21 <=. user ^. UserAge
--   
(<=.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 <=.

-- | This operator translates to the SQL operator <.
--   
--   Example:
--   
--   
--   where_ $ val 20 <. user ^. UserAge
--   
(<.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 <.

-- | This operator translates to the SQL operator !=.
--   
--   Example:
--   
--   
--   where_ $ user ^. UserName !=. val Bob
--   
(!=.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 !=.

-- | This operator translates to the SQL operator AND.
--   
--   Example:
--   
--   
--   where_ $
--           user ^. UserName ==. val Matt
--       &&. user ^. UserAge >=. val 21
--   
(&&.) :: SqlExpr (Value Bool) -> SqlExpr (Value Bool) -> SqlExpr (Value Bool)
infixr 3 &&.

-- | This operator translates to the SQL operator AND.
--   
--   Example:
--   
--   
--   where_ $
--           user ^. UserName ==. val Matt
--       ||. user ^. UserName ==. val John
--   
(||.) :: SqlExpr (Value Bool) -> SqlExpr (Value Bool) -> SqlExpr (Value Bool)
infixr 2 ||.

-- | a between (b, c) translates to the SQL expression
--   a >= b AND a <= c. It does not use a SQL
--   BETWEEN operator.
--   
--   @since: 3.1.0
between :: PersistField a => SqlExpr (Value a) -> (SqlExpr (Value a), SqlExpr (Value a)) -> SqlExpr (Value Bool)

-- | This operator translates to the SQL operator +.
--   
--   This does not require or assume anything about the SQL values.
--   Interpreting what +. means for a given type is left to the
--   database engine.
--   
--   Example:
--   
--   
--   user ^. UserAge +. val 10
--   
(+.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)
infixl 6 +.

-- | This operator translates to the SQL operator -.
--   
--   This does not require or assume anything about the SQL values.
--   Interpreting what -. means for a given type is left to the
--   database engine.
--   
--   Example:
--   
--   
--   user ^. UserAge -. val 10
--   
(-.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)
infixl 6 -.

-- | This operator translates to the SQL operator /.
--   
--   This does not require or assume anything about the SQL values.
--   Interpreting what /. means for a given type is left to the
--   database engine.
--   
--   Example:
--   
--   
--   user ^. UserAge /. val 10
--   
(/.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)
infixl 7 /.

-- | This operator translates to the SQL operator *.
--   
--   This does not require or assume anything about the SQL values.
--   Interpreting what *. means for a given type is left to the
--   database engine.
--   
--   Example:
--   
--   
--   user ^. UserAge *. val 10
--   
(*.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)
infixl 7 *.
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 (Nullable a)))
max_ :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value (Maybe (Nullable 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))

-- | 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.
castNum :: (Num a, Num b) => SqlExpr (Value a) -> SqlExpr (Value b)

-- | Same as castNum, but for nullable values.
castNumM :: (Num a, Num b) => SqlExpr (Value (Maybe a)) -> SqlExpr (Value (Maybe b))

-- | 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.
coalesce :: (PersistField a, NullableFieldProjection a a') => [SqlExpr (Value (Maybe a))] -> SqlExpr (Value (Maybe a'))

-- | Like coalesce, but takes a non-nullable SqlExpression placed
--   at the end of the SqlExpression list, which guarantees a non-NULL
--   result.
coalesceDefault :: PersistField a => [SqlExpr (Value (Maybe a))] -> SqlExpr (Value a) -> SqlExpr (Value a)

-- | LOWER function.
lower_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | UPPER function. @since 3.3.0
upper_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | TRIM function. @since 3.3.0
trim_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | LTRIM function. @since 3.3.0
ltrim_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | RTRIM function. @since 3.3.0
rtrim_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | LENGTH function. @since 3.3.0
length_ :: (SqlString s, Num a) => SqlExpr (Value s) -> SqlExpr (Value a)

-- | LEFT function. @since 3.3.0
left_ :: (SqlString s, Num a) => (SqlExpr (Value s), SqlExpr (Value a)) -> SqlExpr (Value s)

-- | RIGHT function. @since 3.3.0
right_ :: (SqlString s, Num a) => (SqlExpr (Value s), SqlExpr (Value a)) -> SqlExpr (Value s)

-- | LIKE operator.
like :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s) -> SqlExpr (Value Bool)
infixr 2 `like`

-- | ILIKE operator (case-insensitive LIKE).
--   
--   Supported by PostgreSQL only. Deprecated in version 3.6.0 in favor of
--   the version available from Database.Esqueleto.PostgreSQL.

-- | Deprecated: Since 3.6.0: ilike is only supported on
--   Postgres. Please import it from 'Database.Esqueleto.PostgreSQL.
ilike :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s) -> SqlExpr (Value Bool)
infixr 2 `ilike`

-- | 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 `<a>like</a>` (%) ++. val "John" ++. (%)
--   
(%) :: SqlString s => SqlExpr (Value s)

-- | The CONCAT function with a variable number of parameters.
--   Supported by MySQL and PostgreSQL. SQLite supports this in versions
--   after 3.44.0, and persistent-sqlite supports this in versions
--   2.13.3.0 and after.
concat_ :: SqlString s => [SqlExpr (Value s)] -> SqlExpr (Value s)

-- | The || string concatenation operator (named after Haskell's
--   ++ in order to avoid naming clash with ||.).
--   
--   Supported by SQLite and PostgreSQL.
--   
--   MySQL support requires setting the SQL mode to
--   PIPES_AS_CONCAT or ANSI - see this StackOverflow
--   answer.
(++.) :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s) -> SqlExpr (Value s)
infixr 5 ++.

-- | 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.
castString :: (SqlString s, SqlString r) => SqlExpr (Value s) -> SqlExpr (Value r)

-- | Execute a subquery SELECT in an SqlExpression. Returns a list
--   of values.
subList_select :: PersistField a => SqlQuery (SqlExpr (Value a)) -> SqlExpr (ValueList a)

-- | Lift a list of constant value from Haskell-land to the query.
valList :: PersistField typ => [typ] -> SqlExpr (ValueList 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.
justList :: SqlExpr (ValueList typ) -> SqlExpr (ValueList (Maybe typ))

-- | 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 `<tt>in_</tt>` valList personIds
--   return person
--   
--   
--   Where personIds is of type [Key Person].
in_ :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (ValueList typ) -> SqlExpr (Value Bool)

-- | NOT IN operator.
notIn :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (ValueList typ) -> SqlExpr (Value Bool)

-- | EXISTS operator. For example:
--   
--   
--   select $
--   from $ \person -> do
--   where_ $ exists $
--            from $ \post -> do
--            where_ (post ^. BlogPostAuthorId ==. person ^. PersonId)
--   return person
--   
exists :: SqlQuery () -> SqlExpr (Value Bool)

-- | NOT EXISTS operator.
notExists :: SqlQuery () -> SqlExpr (Value Bool)

-- | 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.
set :: PersistEntity val => SqlExpr (Entity val) -> [SqlExpr (Entity val) -> SqlExpr Update] -> SqlQuery ()
(=.) :: (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 statement. For example:
--   
--   
--   select $
--   return $
--   case_
--      [ when_
--          (exists $
--          from $ \p -> do
--          where_ (p ^. PersonName ==. val "Mike"))
--        then_
--          (subSelect $
--          from $ \v -> do
--          let sub =
--                  from $ \c -> do
--                  where_ (c ^. PersonName ==. val "Mike")
--                  return (c ^. PersonFavNum)
--          where_ (just (v ^. PersonFavNum) >. subSelect 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.
--   
case_ :: PersistField a => [(SqlExpr (Value Bool), SqlExpr (Value a))] -> SqlExpr (Value a) -> SqlExpr (Value a)

-- | 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 `<tt>InnerJoin</tt>` 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.
toBaseId :: ToBaseId ent => SqlExpr (Value (Key ent)) -> SqlExpr (Value (Key (BaseEnt ent)))

-- | Like toBaseId, but works on Maybe keys.
toBaseIdMaybe :: ToBaseId ent => SqlExpr (Value (Maybe (Key ent))) -> SqlExpr (Value (Maybe (Key (BaseEnt ent))))

-- | The inverse of toBaseId. Note that this is somewhat less "safe"
--   than toBaseId. Calling toBaseId will usually mean that a
--   foreign key constraint is present that guarantees the presence of the
--   base ID. fromBaseId has no such guarantee. Consider the code
--   example given in toBaseId:
--   
--   
--   Bar
--     barNum Int
--   Foo
--     bar BarId
--     fooNum Int
--     Primary bar
--   
--   
--   
--   instance ToBaseId Foo where
--     type BaseEnt Foo = Bar
--     toBaseIdWitness barId = FooKey barId
--   
--   
--   The type of toBaseId for Foo would be:
--   
--   
--   toBaseId :: SqlExpr (Value FooId) -> SqlExpr (Value BarId)
--   
--   
--   The foreign key constraint on Foo means that every
--   FooId points to a BarId in the database. However,
--   fromBaseId will not have this:
--   
--   
--   fromBaseId :: SqlExpr (Value BarId) -> SqlExpr (Value FooId)
--   
fromBaseId :: ToBaseId ent => SqlExpr (Value (Key (BaseEnt ent))) -> SqlExpr (Value (Key ent))

-- | As fromBaseId, but works on Maybe keys.
fromBaseIdMaybe :: ToBaseId ent => SqlExpr (Value (Maybe (Key (BaseEnt ent)))) -> SqlExpr (Value (Maybe (Key ent)))

-- | 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.
subSelect :: (PersistField a, NullableFieldProjection a a') => SqlQuery (SqlExpr (Value 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).
subSelectMaybe :: PersistField a => SqlQuery (SqlExpr (Value (Maybe a))) -> SqlExpr (Value (Maybe 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.
subSelectCount :: (Num a, PersistField a) => SqlQuery ignored -> 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)
--   
subSelectForeign :: (BackendCompatible SqlBackend (PersistEntityBackend val1), PersistEntity val1, PersistEntity val2, PersistField a) => SqlExpr (Entity val2) -> EntityField val2 (Key val1) -> (SqlExpr (Entity val1) -> SqlExpr (Value a)) -> SqlExpr (Value 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.
subSelectList :: PersistField a => SqlQuery (SqlExpr (Value a)) -> SqlExpr (ValueList a)

-- | Execute a subquery SELECT in a SqlExpr. This function
--   is unsafe, because it can throw runtime exceptions in two cases:
--   
--   
--   
- 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.
--   
- 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.
subSelectUnsafe :: PersistField a => SqlQuery (SqlExpr (Value a)) -> SqlExpr (Value a)

-- | Class that enables one to use toBaseId to convert an entity's
--   key on a query into another (cf. toBaseId).
class ToBaseId ent where {
    
    -- | e.g. <tt>type BaseEnt MyBase = MyChild</tt>
    type BaseEnt 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.
toBaseIdWitness :: ToBaseId ent => Key (BaseEnt ent) -> Key ent

-- | Syntax sugar for case_.
when_ :: expr (Value Bool) -> () -> expr a -> (expr (Value Bool), expr a)

-- | Syntax sugar for case_.
then_ :: ()

-- | Syntax sugar for case_.
else_ :: expr a -> expr a

-- | A single value (as opposed to a whole entity). You may use
--   (^.) or (?.) to get a Value
--   from an Entity.
newtype Value a
Value :: a -> Value a
[unValue] :: Value a -> 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).
newtype ValueList a
ValueList :: a -> ValueList a

-- | Phantom type used by orderBy, asc and desc.
data OrderBy

-- | Phantom type used by distinctOn and don.
data DistinctOn

-- | 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.
data LockingKind

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

-- | Deprecated: The constructors for LockingKind are deprecated
--   in v3.6.0.0. Instead, please refer to the smart constructors
--   forUpdate and forUpdateSkipLocked.
ForUpdate :: LockingKind

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

-- | Deprecated: The constructors for LockingKind are deprecated
--   in v3.6.0.0. Instead, please refer to the smart constructors
--   forUpdate and forUpdateSkipLocked.
ForUpdateSkipLocked :: LockingKind

-- | FOR SHARE syntax. Supported by PostgreSQL.

-- | Deprecated: The constructors for LockingKind are deprecated
--   in v3.6.0.0. Instead, please refer to the smart constructor
--   forShare exported from Database.Esqueleto.PostgreSQL.
ForShare :: LockingKind

-- | LOCK IN SHARE MODE syntax. Supported by MySQL.

-- | Deprecated: The constructors for LockingKind are deprecated
--   in v3.6.0.0. Instead, please refer to the smart constructors
--   lockInShareMode exported from Database.Esqueleto.MySQL.
LockInShareMode :: LockingKind

-- | 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
--   
class LockableEntity a
flattenLockableEntity :: LockableEntity a => a -> NonEmpty LockableSqlExpr

-- | 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.
class PersistField a => SqlString a

-- | Data type that represents an INNER JOIN (see
--   LeftOuterJoin for an example).
data InnerJoin a b
InnerJoin :: a -> b -> InnerJoin a b
infixl 2 `InnerJoin`
infixl 2 `InnerJoin`

-- | Data type that represents a CROSS JOIN (see
--   LeftOuterJoin for an example).
data CrossJoin a b
CrossJoin :: a -> b -> CrossJoin a b
infixl 2 `CrossJoin`
infixl 2 `CrossJoin`

-- | Data type that represents a LEFT OUTER JOIN. For example,
--   
--   
--   select $
--   from $ \(person `<tt>LeftOuterJoin</tt>` pet) ->
--     ...
--   
--   
--   is translated into
--   
--   
--   SELECT ...
--   FROM Person LEFT OUTER JOIN Pet
--   ...
--   
--   
--   See also: from.
data LeftOuterJoin a b
LeftOuterJoin :: a -> b -> LeftOuterJoin a b
infixl 2 `LeftOuterJoin`
infixl 2 `LeftOuterJoin`

-- | Data type that represents a RIGHT OUTER JOIN (see
--   LeftOuterJoin for an example).
data RightOuterJoin a b
RightOuterJoin :: a -> b -> RightOuterJoin a b
infixl 2 `RightOuterJoin`
infixl 2 `RightOuterJoin`

-- | Data type that represents a FULL OUTER JOIN (see
--   LeftOuterJoin for an example).
data FullOuterJoin a b
FullOuterJoin :: a -> b -> FullOuterJoin a b
infixl 2 `FullOuterJoin`
infixl 2 `FullOuterJoin`

-- | (Internal) A kind of JOIN.
data JoinKind

-- | 
--   INNER JOIN
--   
InnerJoinKind :: JoinKind

-- | 
--   CROSS JOIN
--   
CrossJoinKind :: JoinKind

-- | 
--   LEFT OUTER JOIN
--   
LeftOuterJoinKind :: JoinKind

-- | 
--   RIGHT OUTER JOIN
--   
RightOuterJoinKind :: JoinKind

-- | 
--   FULL OUTER JOIN
--   
FullOuterJoinKind :: JoinKind

-- | Exception thrown whenever on is used to create an ON
--   clause but no matching JOIN is found.
data OnClauseWithoutMatchingJoinException
OnClauseWithoutMatchingJoinException :: String -> OnClauseWithoutMatchingJoinException

-- | Get the first table of a given type from a chain of tables joined with
--   (:&).
--   
--   This can make it easier to write queries with a large number of join
--   clauses:
--   
--   
--   select $ do
--   (people :& followers :& blogPosts) <-
--       from $ table @Person
--       `innerJoin` table @Follow
--       `on` (\(person :& follow) ->
--               person ^. PersonId ==. follow ^. FollowFollowed)
--       `innerJoin` table @BlogPost
--       `on` (\((getTable @Follow -> follow) :& blogPost) ->
--               blogPost ^. BlogPostAuthorId ==. follow ^. FollowFollower)
--   where_ (people1 ^. PersonName ==. val "John")
--   pure (followers, people2)
--   
--   
--   This example is a bit trivial, but once you've joined five or six
--   tables it becomes enormously helpful. The above example uses a
--   ViewPattern to call the function and assign the variable
--   directly, but you can also imagine it being written like this:
--   
--   
--   `on` (\(prev :& blogPost) ->
--           let
--               follow = getTable @Follow prev
--            in
--               blogPost ^. BlogPostAuthorId ==. follow ^. FollowFollower)
--   
--   
--   This function will pluck out the first table that matches the applied
--   type, so if you join on the same table multiple times, it will always
--   select the first one provided.
--   
--   The (:&) operator associates so that the left hand side can
--   be a wildcard for an arbitrary amount of nesting, and the "most
--   recent" or "newest" table in a join sequence is always available on
--   the rightmost - so (prev :& bar) is a pattern that
--   matches bar table (the most recent table added) and
--   prev tables (all prior tables in the join match).
--   
--   By calling getTable on the prev, you can select
--   exactly the table you want, allowing you to omit a large number of
--   spurious pattern matches. Consider a query that does several LEFT
--   JOIN on a first table:
--   
--   
--   SELECT *
--   FROM person
--   LEFT JOIN car
--     ON person.id = car.person_id
--   LEFT JOIN bike
--     ON person.id = bike.person_id
--   LEFT JOIN food
--     ON person.id = food.person_id
--   LEFT JOIN address
--     ON person.id = address.person_id
--   
--   
--   The final on clause in esqueleto would look like this:
--   
--   
--   `on` do
--       \(person :& _car :& _bike :& _food :& address) ->
--           person.id ==. address.personId
--   
--   
--   First, we can change it to a prev :& newest match. We can
--   do this because of the operator associativity. This is kind of like
--   how a list : operator associates, but in the other direction:
--   a : (b : c) = a : b : c.
--   
--   
--   `on` do
--       \(prev :& address) ->
--           let (person :& _car :& _bike :& _food) = prev
--            in person.id ==. address.personId
--   
--   
--   Then, we can use getTable to select the Person table
--   directly, instead of pattern matching manually.
--   
--   
--   `on` do
--       \(prev :& address) ->
--           let person = getTable @Person prev
--            in person.id ==. address.personId
--   
--   
--   Finally, we can use a ViewPattern language extension to
--   "inline" the access.
--   
--   
--   `on` do
--       \((getTable @Person -> person) :& address) ->
--          person.id ==. address.personId
--   
--   
--   With this form, you do not need to be concerned about the number and
--   wildcard status of tables that do not matter to the specific
--   ON clause.
getTable :: GetFirstTable (SqlExpr (Entity t)) ts => ts -> SqlExpr (Entity t)

-- | A variant of getTable that operates on possibly-null entities.
getTableMaybe :: GetFirstTable (SqlExpr (Maybe (Entity t))) ts => ts -> SqlExpr (Maybe (Entity t))

-- | Typeclass for selecting tables using type application syntax.
--   
--   If you have a long chain of tables joined with (:&), like
--   a :& b :& c :& d, then getTable @c (a :&
--   b :& c :& d) will give you the c table back.
--   
--   Note that this typeclass will only select the first table of the given
--   type; it may be less useful if there's multiple tables of the same
--   type.
class GetFirstTable t ts

-- | Get the first table of type t from the tables ts.
getFirstTable :: GetFirstTable t ts => ts -> t

-- | SQL backend for esqueleto using SqlPersistT.
data SqlQuery 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.
data SqlExpr a

-- | Constraint synonym for persistent entities whose backend is
--   SqlBackend.
type SqlEntity ent = (PersistEntity ent, PersistEntityBackend ent ~ SqlBackend)

-- | 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).
select :: forall a r (m :: Type -> Type) backend. (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 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
--   
selectOne :: forall a r (m :: Type -> Type) backend. (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 a
--   Source of rows.
selectSource :: forall a r backend (m :: Type -> Type). (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 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)
--   
delete :: forall (m :: Type -> Type) backend. (MonadIO m, SqlBackendCanWrite backend) => SqlQuery () -> ReaderT backend m ()

-- | Same as delete, but returns the number of rows affected.
deleteCount :: forall (m :: Type -> Type) backend. (MonadIO m, SqlBackendCanWrite backend) => SqlQuery () -> ReaderT backend m Int64

-- | 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)
--   
update :: forall (m :: Type -> Type) val backend. (MonadIO m, PersistEntity val, BackendCompatible SqlBackend (PersistEntityBackend val), SqlBackendCanWrite backend) => (SqlExpr (Entity val) -> SqlQuery ()) -> ReaderT backend m ()

-- | Same as update, but returns the number of rows affected.
updateCount :: forall (m :: Type -> Type) val backend. (MonadIO m, PersistEntity val, BackendCompatible SqlBackend (PersistEntityBackend val), SqlBackendCanWrite backend) => (SqlExpr (Entity val) -> SqlQuery ()) -> ReaderT backend m Int64

-- | Insert a PersistField for every selected value.
insertSelect :: forall (m :: Type -> Type) a backend. (MonadIO m, PersistEntity a, SqlBackendCanWrite backend) => SqlQuery (SqlExpr (Insertion a)) -> ReaderT backend m ()

-- | Insert a PersistField for every selected value, return the
--   count afterward
insertSelectCount :: forall (m :: Type -> Type) a backend. (MonadIO m, PersistEntity a, SqlBackendCanWrite backend) => SqlQuery (SqlExpr (Insertion a)) -> ReaderT backend m Int64

-- | Apply a PersistField constructor to SqlExpr Value
--   arguments.
(<#) :: (a -> b) -> SqlExpr (Value a) -> SqlExpr (Insertion b)

-- | Apply extra SqlExpr Value arguments to a PersistField
--   constructor
(<&>) :: SqlExpr (Insertion (a -> b)) -> SqlExpr (Value a) -> SqlExpr (Insertion b)

-- | 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.
renderQueryToText :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => Mode -> SqlQuery a -> 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.
renderQuerySelect :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => SqlQuery a -> 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.
renderQueryUpdate :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => SqlQuery a -> 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.
renderQueryDelete :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => SqlQuery a -> 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.
renderQueryInsertInto :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => SqlQuery a -> ReaderT backend m (Text, [PersistValue])

-- | valkey i = val . toSqlKey
--   (https://github.com/prowdsponsor/esqueleto/issues/9).
valkey :: (ToBackendKey SqlBackend entity, PersistField (Key entity)) => Int64 -> 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).
valJ :: PersistField (Key entity) => Value (Key entity) -> SqlExpr (Value (Key entity))

-- | 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.
associateJoin :: forall e1 e0. Ord (Key e0) => [(Entity e0, e1)] -> Map (Key e0) (e0, [e1])

-- | Synonym for delete that does not clash with
--   esqueleto's delete.
deleteKey :: forall backend val (m :: Type -> Type). (PersistStore backend, BaseBackend backend ~ PersistEntityBackend val, MonadIO m, PersistEntity val) => Key val -> ReaderT backend m ()

-- | 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.
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 allows multiple different backends (databases).
    type PersistEntityBackend record;
    
    -- | By default, a backend will automatically generate the key Instead you
    --   can specify a Primary key made up of unique values.
    data Key record;
    
    -- | An <a>EntityField</a> is parameterised by the Haskell record it
    --   belongs to and the additional type of that field.
    --   
    --   As of <tt>persistent-2.11.0.0</tt>, it's possible to use the
    --   <tt>OverloadedLabels</tt> language extension to refer to
    --   <a>EntityField</a> values polymorphically. See the documentation on
    --   <a>SymbolToField</a> for more information.
    data EntityField record :: Type -> Type;
    
    -- | Unique keys besides the <a>Key</a>.
    data Unique record;
}

-- | A lower-level key operation.
keyToValues :: PersistEntity record => Key record -> [PersistValue]

-- | A lower-level key operation.
keyFromValues :: PersistEntity record => [PersistValue] -> Either Text (Key record)

-- | A meta-operation to retrieve the Key EntityField.
persistIdField :: PersistEntity record => EntityField record (Key record)

-- | Retrieve the EntityDef meta-data for the record.
entityDef :: PersistEntity record => proxy record -> EntityDef

-- | Return meta-data for a given EntityField.
persistFieldDef :: PersistEntity record => EntityField record typ -> FieldDef

-- | A meta-operation to get the database fields of a record.
toPersistFields :: PersistEntity record => record -> [PersistValue]

-- | A lower-level operation to convert from database values to a Haskell
--   record.
fromPersistValues :: PersistEntity record => [PersistValue] -> Either Text 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
--   
tabulateEntityA :: (PersistEntity record, Applicative f) => (forall a. () => EntityField record a -> f a) -> f (Entity record)

-- | Like tabulateEntityA, but works with any Apply f. This
--   works because all entities have at least one field, and so we can
--   tabulate things into semigroup-like shapes instead.
tabulateEntityApply :: (PersistEntity record, Apply f) => (forall a. () => EntityField record a -> f a) -> f (Entity record)

-- | A meta operation to retrieve all the Unique keys.
persistUniqueKeys :: PersistEntity record => record -> [Unique record]

-- | A lower level operation.
persistUniqueToFieldNames :: PersistEntity record => Unique record -> NonEmpty (FieldNameHS, FieldNameDB)

-- | A lower level operation.
persistUniqueToValues :: PersistEntity record => Unique record -> [PersistValue]

-- | Use a PersistField as a lens.
fieldLens :: PersistEntity record => EntityField record field -> forall (f :: Type -> Type). Functor f => (field -> f field) -> Entity record -> f (Entity 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.
keyFromRecordM :: PersistEntity record => Maybe (record -> Key record)

-- | By default, a backend will automatically generate the key Instead you
--   can specify a Primary key made up of unique values.
data family Key record
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

-- | 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). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Key record)

-- | 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   |
--   +-----+------+-----+
--   
insert_ :: forall record (m :: Type -> Type). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m ()

-- | 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). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => [record] -> ReaderT backend m [Key record]

-- | 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   |
--   +-----+------+-----+
--   
insertMany_ :: forall record (m :: Type -> Type). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => [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   |
--   +-----+------+-----+
--   
insertEntityMany :: forall record (m :: Type -> Type). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend) => [Entity 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   |
--   +-----+------+-----+
--   
insertKey :: forall record (m :: Type -> Type). (PersistStoreWrite backend, 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  |
--   +-----+------+-----+
--   
repsert :: forall record (m :: Type -> Type). (PersistStoreWrite backend, 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      |
--   +-----+----------------+---------+
--   
repsertMany :: forall record (m :: Type -> Type). (PersistStoreWrite backend, 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   |
--   +-----+------+-----+
--   
replace :: forall record (m :: Type -> Type). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend) => Key record -> record -> ReaderT backend m ()

-- | 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   |
--   +-----+------+-----+
--   
updateGet :: forall record (m :: Type -> Type). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend) => Key record -> [Update record] -> ReaderT backend m record
data PersistFilter
Eq :: PersistFilter
Ne :: PersistFilter
Gt :: PersistFilter
Lt :: PersistFilter
Ge :: PersistFilter
Le :: PersistFilter
In :: PersistFilter
NotIn :: PersistFilter
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

-- | 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 |
--   +------+-----+
--   
get :: forall record (m :: Type -> Type). (PersistStoreRead backend, MonadIO m, PersistRecordBackend record backend) => Key record -> ReaderT backend m (Maybe 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 |
--   +----+-------+-----+
--   
getMany :: forall record (m :: Type -> Type). (PersistStoreRead backend, MonadIO m, PersistRecordBackend record backend) => [Key record] -> ReaderT backend m (Map (Key record) record)

-- | 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.
--   
class (PersistUniqueRead backend, PersistStoreWrite backend) => PersistUniqueWrite backend

-- | 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   |
--   +-----+------+-----+
--   
deleteBy :: forall record (m :: Type -> Type). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m ()

-- | 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). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Maybe (Key record))

-- | 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.
insertUnique_ :: forall record (m :: Type -> Type). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Maybe ())

-- | 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.
upsert :: forall record (m :: Type -> Type). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend, OnlyOneUniqueKey record, SafeToInsert record) => record -> [Update record] -> ReaderT backend m (Entity record)

-- | 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  |
--   +-----+-----+-----+
--   
upsertBy :: forall record (m :: Type -> Type). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => Unique record -> record -> [Update record] -> ReaderT backend m (Entity record)

-- | Put many records into db
--   
--   
--   
- insert new records that do not exist (or violate any unique
--   constraints)
--   
- replace existing records (matching any unique constraint)
--   
putMany :: forall record (m :: Type -> Type). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => [record] -> ReaderT backend m ()

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

-- | 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.
migrate :: [EntityDef] -> EntityDef -> Migration

-- | Report a single error in a Migration.
reportError :: Text -> Migration

-- | Unique keys besides the Key.
data family Unique record

-- | A single column (see rawSql). Any PersistField may
--   be used here, including PersistValue (which does not do any
--   processing).
newtype Single a
Single :: a -> Single a
[unSingle] :: Single a -> a
data Column
Column :: !FieldNameDB -> !Bool -> !SqlType -> !Maybe Text -> !Maybe Text -> !Maybe ConstraintNameDB -> !Maybe Integer -> !Maybe ColumnReference -> Column
[cName] :: Column -> !FieldNameDB
[cNull] :: Column -> !Bool
[cSqlType] :: Column -> !SqlType
[cDefault] :: Column -> !Maybe Text
[cGenerated] :: Column -> !Maybe Text
[cDefaultConstraintName] :: Column -> !Maybe ConstraintNameDB
[cMaxLen] :: Column -> !Maybe Integer
[cReference] :: Column -> !Maybe ColumnReference

-- | 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)
--   
rawSql :: forall a (m :: Type -> Type) backend. (RawSql a, MonadIO m, BackendCompatible SqlBackend backend) => Text -> [PersistValue] -> ReaderT backend m [a]

-- | 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.
class PersistConfig c where {
    type PersistConfigBackend c :: Type -> Type -> Type -> Type;
    type PersistConfigPool c;
}

-- | Load the config settings from a Value, most likely taken from a
--   YAML config file.
loadConfig :: PersistConfig c => Value -> Parser c

-- | Modify the config settings based on environment variables.
applyEnv :: PersistConfig c => c -> IO c

-- | Create a new connection pool based on the given config settings.
createPoolConfig :: PersistConfig c => c -> IO (PersistConfigPool c)

-- | Run a database action by taking a connection from the pool.
runPool :: (PersistConfig c, MonadUnliftIO m) => c -> PersistConfigBackend c m a -> PersistConfigPool c -> m a
type family PersistConfigBackend c :: Type -> Type -> Type -> Type
type family PersistConfigPool c

-- | An ConstraintNameHS represents the Haskell-side name that
--   persistent will use for a constraint.
newtype ConstraintNameHS
ConstraintNameHS :: Text -> ConstraintNameHS
[unConstraintNameHS] :: ConstraintNameHS -> Text

-- | A ConstraintNameDB represents the datastore-side name that
--   persistent will use for a constraint.
newtype ConstraintNameDB
ConstraintNameDB :: Text -> ConstraintNameDB
[unConstraintNameDB] :: ConstraintNameDB -> Text

-- | An EntityNameDB represents the datastore-side name that
--   persistent will use for an entity.
newtype EntityNameDB
EntityNameDB :: Text -> EntityNameDB
[unEntityNameDB] :: EntityNameDB -> Text

-- | An EntityNameHS represents the Haskell-side name that
--   persistent will use for an entity.
newtype EntityNameHS
EntityNameHS :: Text -> EntityNameHS
[unEntityNameHS] :: EntityNameHS -> Text

-- | A FieldNameHS represents the Haskell-side name that
--   persistent will use for a field.
newtype FieldNameHS
FieldNameHS :: Text -> FieldNameHS
[unFieldNameHS] :: FieldNameHS -> Text

-- | A FieldNameDB represents the datastore-side name that
--   persistent will use for a field.
newtype FieldNameDB
FieldNameDB :: Text -> FieldNameDB
[unFieldNameDB] :: FieldNameDB -> Text

-- | Convenience operations for working with '-NameDB' types.
class DatabaseName a
escapeWith :: DatabaseName a => (Text -> str) -> a -> str

-- | A type that determines how a backend should handle the literal.
data LiteralType

-- | The accompanying value will be escaped before inserting into the
--   database. This is the correct default choice to use.
Escaped :: LiteralType

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

-- | 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.
DbSpecific :: LiteralType

-- | A raw value which can be stored in any backend and can be marshalled
--   to and from a PersistField.
data PersistValue
PersistText :: Text -> PersistValue
PersistByteString :: ByteString -> PersistValue
PersistInt64 :: Int64 -> PersistValue
PersistDouble :: Double -> PersistValue
PersistRational :: Rational -> PersistValue
PersistBool :: Bool -> PersistValue
PersistDay :: Day -> PersistValue
PersistTimeOfDay :: TimeOfDay -> PersistValue
PersistUTCTime :: UTCTime -> PersistValue
PersistNull :: PersistValue
PersistList :: [PersistValue] -> PersistValue
PersistMap :: [(Text, PersistValue)] -> PersistValue

-- | Intended especially for MongoDB backend
PersistObjectId :: ByteString -> PersistValue

-- | Intended especially for PostgreSQL backend for text arrays
PersistArray :: [PersistValue] -> PersistValue

-- | 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.
PersistLiteral_ :: LiteralType -> 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.
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.
pattern PersistLiteralEscaped :: 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.
pattern PersistDbSpecific :: ByteString -> PersistValue
fromPersistValueText :: PersistValue -> Either Text Text

-- | Please refer to the documentation for the database in question for a
--   full overview of the semantics of the varying isolation levels
data IsolationLevel
ReadUncommitted :: IsolationLevel
ReadCommitted :: IsolationLevel
RepeatableRead :: IsolationLevel
Serializable :: IsolationLevel

-- | 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.
data FieldDef
FieldDef :: !FieldNameHS -> !FieldNameDB -> !FieldType -> !SqlType -> ![FieldAttr] -> !Bool -> !ReferenceDef -> !FieldCascade -> !Maybe Text -> !Maybe Text -> !Bool -> FieldDef

-- | 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.
[fieldHaskell] :: FieldDef -> !FieldNameHS

-- | The name of the field in the database. For SQL databases, this
--   corresponds to the column name.
[fieldDB] :: FieldDef -> !FieldNameDB

-- | The type of the field in Haskell.
[fieldType] :: FieldDef -> !FieldType

-- | The type of the field in a SQL database.
[fieldSqlType] :: FieldDef -> !SqlType

-- | User annotations for a field. These are provided with the !
--   operator.
[fieldAttrs] :: FieldDef -> ![FieldAttr]

-- | If this is True, then the Haskell datatype will have a strict
--   record field. The default value for this is True.
[fieldStrict] :: FieldDef -> !Bool
[fieldReference] :: FieldDef -> !ReferenceDef

-- | 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.
[fieldCascade] :: FieldDef -> !FieldCascade

-- | Optional comments for a Field.
[fieldComments] :: FieldDef -> !Maybe Text

-- | Whether or not the field is a GENERATED column, and
--   additionally the expression to use for generation.
[fieldGenerated] :: FieldDef -> !Maybe Text

-- | True if the field is an implicit ID column. False
--   otherwise.
[fieldIsImplicitIdColumn] :: FieldDef -> !Bool
data PersistUpdate
Assign :: PersistUpdate
Add :: PersistUpdate
Subtract :: PersistUpdate
Multiply :: PersistUpdate
Divide :: PersistUpdate
BackendSpecificUpdate :: Text -> PersistUpdate
type family BackendSpecificUpdate backend record
data UpdateException
KeyNotFound :: String -> UpdateException
UpsertError :: String -> UpdateException

-- | 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.
data SqlType
SqlString :: SqlType
SqlInt32 :: SqlType
SqlInt64 :: SqlType
SqlReal :: SqlType
SqlNumeric :: Word32 -> Word32 -> SqlType
SqlBool :: SqlType
SqlDay :: SqlType
SqlTime :: SqlType

-- | Always uses UTC timezone
SqlDayTime :: SqlType
SqlBlob :: SqlType

-- | a backend-specific name
SqlOther :: Text -> SqlType
data PersistException

-- | Generic Exception
PersistError :: Text -> PersistException
PersistMarshalError :: Text -> PersistException
PersistInvalidField :: Text -> PersistException
PersistForeignConstraintUnmet :: Text -> PersistException
PersistMongoDBError :: Text -> PersistException
PersistMongoDBUnsupported :: Text -> PersistException

-- | An action that might happen on a deletion or update on a foreign key
--   change.
data CascadeAction
Cascade :: CascadeAction
Restrict :: CascadeAction
SetNull :: CascadeAction
SetDefault :: CascadeAction

-- | 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.
data FieldCascade
FieldCascade :: !Maybe CascadeAction -> !Maybe CascadeAction -> FieldCascade
[fcOnUpdate] :: FieldCascade -> !Maybe CascadeAction
[fcOnDelete] :: FieldCascade -> !Maybe CascadeAction
data ForeignDef
ForeignDef :: !EntityNameHS -> !EntityNameDB -> !ConstraintNameHS -> !ConstraintNameDB -> !FieldCascade -> ![(ForeignFieldDef, ForeignFieldDef)] -> ![Attr] -> Bool -> Bool -> ForeignDef
[foreignRefTableHaskell] :: ForeignDef -> !EntityNameHS
[foreignRefTableDBName] :: ForeignDef -> !EntityNameDB
[foreignConstraintNameHaskell] :: ForeignDef -> !ConstraintNameHS
[foreignConstraintNameDBName] :: ForeignDef -> !ConstraintNameDB

-- | Determine how the field will cascade on updates and deletions.
[foreignFieldCascade] :: ForeignDef -> !FieldCascade
[foreignFields] :: ForeignDef -> ![(ForeignFieldDef, ForeignFieldDef)]
[foreignAttrs] :: ForeignDef -> ![Attr]
[foreignNullable] :: ForeignDef -> Bool

-- | Determines if the reference is towards a Primary Key or not.
[foreignToPrimary] :: ForeignDef -> Bool

-- | Used instead of FieldDef to generate a smaller amount of code
type ForeignFieldDef = (FieldNameHS, FieldNameDB)
data CompositeDef
CompositeDef :: !NonEmpty FieldDef -> ![Attr] -> CompositeDef
[compositeFields] :: CompositeDef -> !NonEmpty FieldDef
[compositeAttrs] :: CompositeDef -> ![Attr]

-- | 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 = []
--       }
--   
data UniqueDef
UniqueDef :: !ConstraintNameHS -> !ConstraintNameDB -> !NonEmpty (FieldNameHS, FieldNameDB) -> ![Attr] -> UniqueDef
[uniqueHaskell] :: UniqueDef -> !ConstraintNameHS
[uniqueDBName] :: UniqueDef -> !ConstraintNameDB
[uniqueFields] :: UniqueDef -> !NonEmpty (FieldNameHS, FieldNameDB)
[uniqueAttrs] :: UniqueDef -> ![Attr]

-- | An EmbedFieldDef is the same as a FieldDef But it is only used for
--   embeddedFields so it only has data needed for embedding
data EmbedFieldDef
EmbedFieldDef :: FieldNameDB -> Maybe (Either SelfEmbed EntityNameHS) -> EmbedFieldDef
[emFieldDB] :: EmbedFieldDef -> FieldNameDB
[emFieldEmbed] :: EmbedFieldDef -> Maybe (Either SelfEmbed EntityNameHS)

-- | An EmbedEntityDef is the same as an EntityDef But it is only used for
--   fieldReference so it only has data needed for embedding
data EmbedEntityDef
EmbedEntityDef :: EntityNameHS -> [EmbedFieldDef] -> EmbedEntityDef
[embeddedHaskell] :: EmbedEntityDef -> EntityNameHS
[embeddedFields] :: EmbedEntityDef -> [EmbedFieldDef]

-- | There are 3 kinds of references 1) composite (to fields that exist in
--   the record) 2) single field 3) embedded
data ReferenceDef
NoReference :: ReferenceDef

-- | 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
ForeignRef :: !EntityNameHS -> ReferenceDef
EmbedRef :: EntityNameHS -> ReferenceDef

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

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

-- | Optional module and name.
FTTypeCon :: Maybe Text -> Text -> FieldType
FTLit :: FieldTypeLit -> FieldType
FTTypePromoted :: Text -> FieldType
FTApp :: FieldType -> FieldType -> FieldType
FTList :: FieldType -> FieldType

-- | 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.
data FieldAttr

-- | 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
--   
FieldAttrMaybe :: FieldAttr

-- | 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
--   
FieldAttrNullable :: FieldAttr

-- | 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
--   
FieldAttrMigrationOnly :: FieldAttr

-- | 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
--   
FieldAttrSafeToRemove :: FieldAttr

-- | 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
--   
FieldAttrNoreference :: FieldAttr

-- | 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.
FieldAttrReference :: Text -> FieldAttr

-- | 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"
--   
FieldAttrConstraint :: Text -> FieldAttr

-- | 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.
FieldAttrDefault :: Text -> FieldAttr

-- | 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
--   
FieldAttrSqltype :: Text -> FieldAttr

-- | Set a maximum length for a column. Useful for VARCHAR and indexes.
--   
--   
--   User
--       name     Text    maxlen=200
--   
--       UniqueName name
--   
FieldAttrMaxlen :: Integer -> FieldAttr

-- | 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.
FieldAttrSql :: Text -> FieldAttr

-- | A grab bag of random attributes that were unrecognized by the parser.
FieldAttrOther :: Text -> FieldAttr
type Attr = Text
type ExtraLine = [Text]

-- | The definition for the entity's primary key ID.
data EntityIdDef

-- | The entity has a single key column, and it is a surrogate key - that
--   is, you can't go from rec -> Key rec.
EntityIdField :: !FieldDef -> EntityIdDef

-- | 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.
EntityIdNaturalKey :: !CompositeDef -> EntityIdDef

-- | 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.
data EntityDef

-- | 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.
data WhyNullable
ByMaybeAttr :: WhyNullable
ByNullableAttr :: WhyNullable
data IsNullable
Nullable :: !WhyNullable -> IsNullable
NotNullable :: IsNullable

-- | 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.
data Checkmark

-- | When used on a uniqueness constraint, there may be at most one
--   Active record.
Active :: Checkmark

-- | When used on a uniqueness constraint, there may be any number of
--   Inactive records.
Inactive :: Checkmark
fieldAttrsContainsNullable :: [FieldAttr] -> IsNullable

-- | Return the [FieldDef] for the entity keys.
entitiesPrimary :: EntityDef -> NonEmpty FieldDef
entityPrimary :: EntityDef -> Maybe CompositeDef

-- | Returns a NonEmpty list of FieldDef that correspond with
--   the key columns for an EntityDef.
keyAndEntityFields :: EntityDef -> NonEmpty FieldDef

-- | Returns a NonEmpty list of FieldDef that correspond with
--   the key columns for an 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 fields on the Haskell type use keyAndEntityFieldsDatabase
keyAndEntityFieldsDatabase :: EntityDef -> NonEmpty FieldDef

-- | Parse raw field attributes into structured form. Any unrecognized
--   attributes will be preserved, identically as they are encountered, as
--   FieldAttrOther values.
parseFieldAttrs :: [Text] -> [FieldAttr]
isFieldNotGenerated :: FieldDef -> Bool

-- | Returns True if the FieldDef does not have a
--   MigrationOnly or SafeToRemove flag from the
--   QuasiQuoter.
isHaskellField :: FieldDef -> Bool

-- | A FieldCascade that does nothing.
noCascade :: FieldCascade

-- | Renders a FieldCascade value such that it can be used in SQL
--   migrations.
renderFieldCascade :: FieldCascade -> Text

-- | Render a CascadeAction to Text such that it can be used
--   in a SQL command.
renderCascadeAction :: CascadeAction -> Text

-- | A Statement is a representation of a database query that has
--   been prepared and stored on the server side.
data Statement
Statement :: IO () -> IO () -> ([PersistValue] -> IO Int64) -> (forall (m :: Type -> Type). MonadIO m => [PersistValue] -> Acquire (ConduitM () [PersistValue] m ())) -> Statement
[stmtFinalize] :: Statement -> IO ()
[stmtReset] :: Statement -> IO ()
[stmtExecute] :: Statement -> [PersistValue] -> IO Int64
[stmtQuery] :: Statement -> forall (m :: Type -> Type). MonadIO m => [PersistValue] -> Acquire (ConduitM () [PersistValue] m ())
data InsertSqlResult
ISRSingle :: Text -> InsertSqlResult
ISRInsertGet :: Text -> Text -> InsertSqlResult
ISRManyKeys :: Text -> [PersistValue] -> InsertSqlResult
type LogFunc = Loc -> LogSource -> LogLevel -> LogStr -> IO ()

-- | Replace the FieldDef FieldAttr with the new list.
setFieldAttrs :: [FieldAttr] -> FieldDef -> FieldDef

-- | Modify the list of field attributes.
overFieldAttrs :: ([FieldAttr] -> [FieldAttr]) -> FieldDef -> FieldDef

-- | Add an attribute to the list of field attributes.
addFieldAttr :: FieldAttr -> FieldDef -> FieldDef

-- | Check if the field definition is nullable
isFieldNullable :: FieldDef -> IsNullable

-- | Check if the field is `Maybe a`
isFieldMaybe :: FieldDef -> Bool

-- | 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.
getEntityUniquesNoPrimaryKey :: 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.
getEntityUniques :: EntityDef -> [UniqueDef]

-- | Retrieve the Haskell name of the given entity.
getEntityHaskellName :: EntityDef -> EntityNameHS

-- | Return the database name for the given entity.
getEntityDBName :: EntityDef -> EntityNameDB
getEntityExtra :: EntityDef -> Map Text [[Text]]

setEntityDBName :: EntityNameDB -> EntityDef -> EntityDef
getEntityComments :: EntityDef -> Maybe Text

getEntityForeignDefs :: EntityDef -> [ForeignDef]

-- | 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.
getEntityFields :: 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.
getEntityFieldsDatabase :: EntityDef -> [FieldDef]

isEntitySum :: EntityDef -> Bool

getEntityId :: EntityDef -> EntityIdDef

getEntityIdField :: EntityDef -> Maybe FieldDef

-- | Set an entityId to be the given FieldDef.
setEntityId :: FieldDef -> EntityDef -> EntityDef

setEntityIdDef :: EntityIdDef -> EntityDef -> EntityDef

getEntityKeyFields :: EntityDef -> NonEmpty FieldDef

-- | Perform a mapping function over all of the entity fields, as
--   determined by getEntityFieldsDatabase.
overEntityFields :: ([FieldDef] -> [FieldDef]) -> EntityDef -> EntityDef

-- | Gets the Source of the definition of the entity.
--   
--   Note that as of this writing the span covers the entire file or
--   quasiquote where the item is defined due to parsing limitations. This
--   may be changed in a future release to be more accurate.
getEntitySpan :: EntityDef -> Maybe SourceSpan

-- | 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.
newtype OverflowNatural
OverflowNatural :: Natural -> OverflowNatural
[unOverflowNatural] :: OverflowNatural -> Natural

-- | 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 Text
--    deriving (Eq, Show, PersistFieldSql)
--   
--   mkSSN :: Text -> Either Text 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.
--   
class PersistField a
toPersistValue :: PersistField a => a -> PersistValue
fromPersistValue :: PersistField a => PersistValue -> Either Text 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.
class SafeToInsert a

-- | 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.
class SymbolToField (sym :: Symbol) rec typ | sym rec -> typ
symbolToField :: SymbolToField sym rec typ => EntityField rec typ

-- | 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.
data Entity record
Entity :: Key record -> record -> Entity record
[entityKey] :: Entity record -> Key record
[entityVal] :: Entity record -> record

-- | Value to filter with. Highly dependant on the type of filter used.
data FilterValue typ
[FilterValue] :: forall typ. typ -> FilterValue typ
[FilterValues] :: forall typ. [typ] -> FilterValue typ
[UnsafeValue] :: forall a typ. PersistField a => a -> FilterValue typ

-- | Persistent allows multiple different backends (databases).
type family PersistEntityBackend record

-- | 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 family EntityField record :: Type -> Type

-- | 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.
tabulateEntity :: PersistEntity record => (forall a. () => EntityField record a -> a) -> Entity record

-- | Get list of values corresponding to given entity.
entityValues :: PersistEntity record => Entity record -> [PersistValue]

-- | Predefined toJSON. The resulting JSON looks like {"key":
--   1, "value": {"name": ...}}.
--   
--   The typical usage is:
--   
--   
--   instance ToJSON (Entity User) where
--       toJSON = keyValueEntityToJSON
--   
keyValueEntityToJSON :: (PersistEntity record, ToJSON record) => Entity record -> Value

-- | Predefined parseJSON. The input JSON looks like {"key":
--   1, "value": {"name": ...}}.
--   
--   The typical usage is:
--   
--   
--   instance FromJSON (Entity User) where
--       parseJSON = keyValueEntityFromJSON
--   
keyValueEntityFromJSON :: (PersistEntity record, FromJSON record) => Value -> Parser (Entity record)

-- | Predefined toJSON. The resulting JSON looks like {"id":
--   1, "name": ...}.
--   
--   The typical usage is:
--   
--   
--   instance ToJSON (Entity User) where
--       toJSON = entityIdToJSON
--   
entityIdToJSON :: (PersistEntity record, ToJSON record) => Entity record -> Value

-- | Predefined parseJSON. The input JSON looks like {"id": 1,
--   "name": ...}.
--   
--   The typical usage is:
--   
--   
--   instance FromJSON (Entity User) where
--       parseJSON = entityIdFromJSON
--   
entityIdFromJSON :: (PersistEntity record, FromJSON record) => Value -> Parser (Entity record)

-- | 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
--   
toPersistValueJSON :: ToJSON a => a -> PersistValue

-- | 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
--   
fromPersistValueJSON :: FromJSON a => PersistValue -> Either Text a
class PersistCore backend where {
    data BackendKey backend;
}
data family BackendKey backend

-- | 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.
class (PersistEntity record, PersistEntityBackend record ~ backend, PersistCore backend) => ToBackendKey backend record
toBackendKey :: ToBackendKey backend record => Key record -> BackendKey backend
fromBackendKey :: ToBackendKey backend record => BackendKey backend -> Key record

-- | A convenient alias for common type signatures
type PersistRecordBackend record backend = (PersistEntity record, PersistEntityBackend record ~ BaseBackend backend)

-- | 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
--   
class BackendCompatible sup sub
projectBackend :: BackendCompatible sup sub => sub -> sup

-- | 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.
class HasPersistBackend backend => IsPersistBackend backend

-- | 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 
class HasPersistBackend backend where {
    type BaseBackend backend;
}
persistBackend :: HasPersistBackend backend => backend -> BaseBackend backend
type family BaseBackend backend

-- | 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.
withBaseBackend :: forall backend (m :: Type -> Type) a. HasPersistBackend backend => ReaderT (BaseBackend backend) m a -> ReaderT backend 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.
withCompatibleBackend :: forall sup sub (m :: Type -> Type) a. BackendCompatible sup sub => ReaderT sup m a -> ReaderT sub m a
liftPersist :: (MonadIO m, MonadReader backend m) => ReaderT backend IO b -> m b

-- | 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.
getJust :: forall record backend (m :: Type -> Type). (PersistStoreRead backend, PersistRecordBackend record backend, MonadIO m) => Key record -> ReaderT backend m 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 |
--   +----+------+-----+
--   
getJustEntity :: forall record backend (m :: Type -> Type). (PersistEntityBackend record ~ BaseBackend backend, MonadIO m, PersistEntity record, PersistStoreRead backend) => Key record -> ReaderT backend m (Entity record)

-- | Curry this to make a convenience function that loads an associated
--   model.
--   
--   
--   foreign = belongsTo foreignId
--   
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)

-- | Same as belongsTo, but uses getJust and therefore is
--   similarly unsafe.
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

-- | 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 |
--   +----+---------+-----+
--   
insertEntity :: forall e backend (m :: Type -> Type). (PersistStoreWrite backend, PersistRecordBackend e backend, SafeToInsert e, MonadIO m, HasCallStack) => e -> ReaderT backend m (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 |
--   +----+------+-----+
--   
getEntity :: forall e backend (m :: Type -> Type). (PersistStoreRead backend, PersistRecordBackend e backend, MonadIO m) => Key e -> ReaderT backend m (Maybe (Entity e))

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

-- | 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.
data SqlBackend

-- | 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.
class PersistEntity record => AtLeastOneUniqueKey record
requireUniquesP :: AtLeastOneUniqueKey record => record -> NonEmpty (Unique record)

-- | This is an error message. It is used when an entity has multiple
--   unique keys, and the function expects a single unique key.
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 writing instances of
--   OnlyOneUniqueKey for an entity that has no unique keys.
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 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.
class PersistEntity record => OnlyOneUniqueKey record
onlyUniqueP :: OnlyOneUniqueKey record => record -> Unique record

-- | 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.
class PersistStoreRead backend => PersistUniqueRead backend

-- | 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 |
--   +----+------+-----+
--   
getBy :: forall record (m :: Type -> Type). (PersistUniqueRead backend, MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m (Maybe (Entity record))

-- | 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.
existsBy :: forall record (m :: Type -> Type). (PersistUniqueRead backend, MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m Bool

-- | Given a proxy for a PersistEntity record, this returns the sole
--   UniqueDef for that entity.
onlyOneUniqueDef :: (OnlyOneUniqueKey record, Monad proxy) => proxy record -> UniqueDef

-- | 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 |
--   +----+-------+-----+
--   
insertUniqueEntity :: forall record backend (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, PersistUniqueWrite backend, SafeToInsert record) => record -> ReaderT backend m (Maybe (Entity 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.
onlyUnique :: forall record backend (m :: Type -> Type). (MonadIO m, PersistUniqueWrite backend, PersistRecordBackend record backend, OnlyOneUniqueKey record) => record -> ReaderT backend m (Unique 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 |
--   +----+------+-----+
--   
getByValue :: forall record (m :: Type -> Type) backend. (MonadIO m, PersistUniqueRead backend, PersistRecordBackend record backend, AtLeastOneUniqueKey record) => record -> ReaderT backend m (Maybe (Entity 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
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))

-- | 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
--   
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 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
--   
checkUniqueUpdateable :: forall record backend (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, PersistUniqueRead backend) => Entity record -> ReaderT backend m (Maybe (Unique record))

-- | Backends supporting conditional write operations
class (PersistQueryRead backend, PersistStoreWrite backend) => PersistQueryWrite backend

-- | Update individual fields on any record matching the given criterion.
updateWhere :: forall (m :: Type -> Type) record. (PersistQueryWrite backend, MonadIO m, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> ReaderT backend m ()

-- | Delete all records matching the given criterion.
deleteWhere :: forall (m :: Type -> Type) record. (PersistQueryWrite backend, MonadIO m, PersistRecordBackend record backend) => [Filter record] -> ReaderT backend m ()

-- | Backends supporting conditional read operations.
class (PersistCore backend, PersistStoreRead backend) => PersistQueryRead backend

-- | 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.
selectSourceRes :: forall record (m1 :: Type -> Type) (m2 :: Type -> Type). (PersistQueryRead backend, PersistRecordBackend record backend, MonadIO m1, MonadIO m2) => [Filter record] -> [SelectOpt record] -> ReaderT backend m1 (Acquire (ConduitM () (Entity record) m2 ()))

-- | Get just the first record for the criterion.
selectFirst :: forall (m :: Type -> Type) record. (PersistQueryRead backend, MonadIO m, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))

-- | Get the Keys of all records matching the given criterion.
selectKeysRes :: forall (m1 :: Type -> Type) (m2 :: Type -> Type) record. (PersistQueryRead backend, 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.
--   
--   For an example, see selectList.
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 ()

-- | 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 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 backend which is a wrapper around SqlBackend.
type IsSqlBackend backend = (IsPersistBackend backend, BaseBackend backend ~ SqlBackend)

-- | Like SqlPersistT but compatible with any SQL backend which
--   can handle read and write queries.
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 queries.
type SqlReadT (m :: Type -> Type) a = forall backend. SqlBackendCanRead backend => ReaderT backend m a

-- | A constraint synonym which witnesses that a backend is SQL and can run
--   read and write 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 queries.
type SqlBackendCanRead backend = (BackendCompatible SqlBackend backend, PersistQueryRead backend, PersistStoreRead backend, PersistUniqueRead backend)

-- | An SQL backend which can handle read or write queries
--   
--   The constructor was exposed in 2.10.0
newtype SqlWriteBackend
SqlWriteBackend :: SqlBackend -> SqlWriteBackend
[unSqlWriteBackend] :: SqlWriteBackend -> SqlBackend

-- | An SQL backend which can only handle read queries
--   
--   The constructor was exposed in 2.10.0.
newtype SqlReadBackend
SqlReadBackend :: SqlBackend -> SqlReadBackend
[unSqlReadBackend] :: SqlReadBackend -> SqlBackend

-- | Useful for running a write query against an untagged backend with
--   unknown capabilities.
writeToUnknown :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlWriteBackend m a -> ReaderT SqlBackend m a

-- | Useful for running a read query against a backend with read and write
--   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 unknown
--   capabilities.
readToUnknown :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlReadBackend m a -> ReaderT SqlBackend m a

-- | Values to configure a pool of database connections. See
--   Data.Pool for details.
data ConnectionPoolConfig
ConnectionPoolConfig :: Int -> NominalDiffTime -> Int -> ConnectionPoolConfig

-- | How many stripes to divide the pool into. See Data.Pool for
--   details. Default: 1.
[connectionPoolConfigStripes] :: ConnectionPoolConfig -> Int

-- | How long connections can remain idle before being disposed of, in
--   seconds. Default: 600
[connectionPoolConfigIdleTimeout] :: ConnectionPoolConfig -> NominalDiffTime

-- | How many connections should be held in the connection pool. Default:
--   10
[connectionPoolConfigSize] :: ConnectionPoolConfig -> Int
type ConnectionPool = Pool SqlBackend
type SqlPersistM = SqlPersistT NoLoggingT ResourceT IO
type SqlPersistT = ReaderT SqlBackend
data PersistentSqlException
StatementAlreadyFinalized :: Text -> PersistentSqlException
Couldn'tGetSQLConnection :: PersistentSqlException

-- | This value specifies how a field references another table.
data ColumnReference
ColumnReference :: !EntityNameDB -> !ConstraintNameDB -> !FieldCascade -> ColumnReference

-- | The table name that the
[crTableName] :: ColumnReference -> !EntityNameDB

-- | The name of the foreign key constraint.
[crConstraintName] :: ColumnReference -> !ConstraintNameDB

-- | Whether or not updates/deletions to the referenced table cascade to
--   this table.
[crFieldCascade] :: ColumnReference -> !FieldCascade

-- | Initializes a ConnectionPoolConfig with default values. See the
--   documentation of ConnectionPoolConfig for each field's default
--   value.
defaultConnectionPoolConfig :: ConnectionPoolConfig

-- | 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.
data BackendSpecificOverrides

-- | 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
getBackendSpecificForeignKeyName :: BackendSpecificOverrides -> Maybe (EntityNameDB -> FieldNameDB -> ConstraintNameDB)

-- | Set the backend's foreign key generation function to this value.
setBackendSpecificForeignKeyName :: (EntityNameDB -> FieldNameDB -> ConstraintNameDB) -> BackendSpecificOverrides -> BackendSpecificOverrides

-- | Creates an empty BackendSpecificOverrides (i.e. use the default
--   behavior; no overrides)
emptyBackendSpecificOverrides :: BackendSpecificOverrides
defaultAttribute :: [FieldAttr] -> Maybe Text

-- | Create the list of columns for the given entity.
mkColumns :: [EntityDef] -> EntityDef -> BackendSpecificOverrides -> ([Column], [UniqueDef], [ForeignDef])

-- | A more general way to convert instances of ToJSON type class to
--   strict text Text.
toJsonText :: ToJSON j => j -> Text

-- | 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"
--   
class PersistField a => PersistFieldSql a
sqlType :: PersistFieldSql a => Proxy a -> SqlType

-- | 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.
newtype EntityWithPrefix (prefix :: Symbol) record
EntityWithPrefix :: Entity record -> EntityWithPrefix (prefix :: Symbol) record
[unEntityWithPrefix] :: EntityWithPrefix (prefix :: Symbol) record -> Entity record

-- | Class for data types that may be retrived from a rawSql
--   query.
class RawSql a

-- | Number of columns that this data type needs and the list of
--   substitutions for SELECT placeholders ??.
rawSqlCols :: RawSql a => (Text -> Text) -> a -> (Int, [Text])

-- | A string telling the user why the column count is what it is.
rawSqlColCountReason :: RawSql a => a -> String

-- | Transform a row of the result into the data type.
rawSqlProcessRow :: RawSql a => [PersistValue] -> Either Text a

-- | 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"
--   
unPrefix :: forall (prefix :: Symbol) record. EntityWithPrefix prefix record -> Entity record
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 ()))

-- | Execute a raw SQL statement
rawExecute :: forall (m :: Type -> Type) backend. (MonadIO m, BackendCompatible SqlBackend backend) => Text -> [PersistValue] -> ReaderT backend m ()

-- | Execute a raw SQL statement and return the number of rows it has
--   modified.
rawExecuteCount :: forall (m :: Type -> Type) backend. (MonadIO m, BackendCompatible SqlBackend backend) => Text -> [PersistValue] -> ReaderT backend m Int64
getStmtConn :: SqlBackend -> Text -> IO Statement

-- | 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.
runSqlPool :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> m a

-- | Like runSqlPool, but supports specifying an isolation level.
runSqlPoolWithIsolation :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> IsolationLevel -> m a

-- | Like runSqlPool, but does not surround the action in a
--   transaction. This action might leave your database in a weird state.
runSqlPoolNoTransaction :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> 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.
runSqlPoolWithHooks :: forall backend m a before after onException. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> (backend -> m before) -> (backend -> m after) -> (backend -> SomeException -> m onException) -> m a

-- | This function is how runSqlPoolWithHooks is defined.
--   
--   It's currently the most general function for using a SQL pool.
runSqlPoolWithExtensibleHooks :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> SqlPoolHooks m backend -> m a

-- | 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.
acquireSqlConn :: (MonadReader backend m, BackendCompatible SqlBackend backend) => m (Acquire backend)

-- | Like acquireSqlConn, but lets you specify an explicit isolation
--   level.
acquireSqlConnWithIsolation :: (MonadReader backend m, BackendCompatible SqlBackend backend) => IsolationLevel -> m (Acquire backend)
runSqlConn :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> backend -> m a

-- | Like runSqlConn, but supports specifying an isolation level.
runSqlConnWithIsolation :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> backend -> IsolationLevel -> m a
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 :: forall backend m a. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> Int -> (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.
withSqlPoolWithConfig :: forall backend m a. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> ConnectionPoolConfig -> (Pool backend -> m a) -> m a
createSqlPool :: forall backend m. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> Int -> m (Pool backend)

-- | Creates a pool of connections to a SQL database.
createSqlPoolWithConfig :: (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> ConnectionPoolConfig -> m (Pool backend)

-- | 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}}]
--   
withSqlConn :: forall backend m a. (MonadUnliftIO m, MonadLoggerIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> (backend -> m a) -> m a
close' :: BackendCompatible SqlBackend backend => backend -> IO ()
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

-- | 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
getTableName :: forall record (m :: Type -> Type) backend. (PersistEntity record, BackendCompatible SqlBackend backend, Monad m) => record -> ReaderT backend m Text

-- | useful for a backend to implement tableName by adding escaping
tableDBName :: PersistEntity record => record -> EntityNameDB

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

-- | useful for a backend to implement fieldName by adding escaping
fieldDBName :: PersistEntity record => EntityField record typ -> FieldNameDB

-- | Used when determining how to prefix a column name in a WHERE
--   clause.
data FilterTablePrefix

-- | Prefix the column with the table name. This is useful if the column
--   name might be ambiguous.
PrefixTableName :: FilterTablePrefix

-- | 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.
PrefixExcluded :: FilterTablePrefix

-- | Render a [Filter record] into a Text value
--   suitable for inclusion into a SQL query.
filterClause :: PersistEntity val => Maybe FilterTablePrefix -> SqlBackend -> [Filter val] -> Text

-- | 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.
filterClauseWithVals :: PersistEntity val => Maybe FilterTablePrefix -> SqlBackend -> [Filter val] -> (Text, [PersistValue])

-- | Render a [SelectOpt record] made up *only* of
--   Asc and Desc constructors into a Text value
--   suitable for inclusion into a SQL query.
orderClause :: PersistEntity val => Maybe FilterTablePrefix -> SqlBackend -> [SelectOpt val] -> Text

-- | Generates sql for limit and offset for postgres, sqlite and mysql.
decorateSQLWithLimitOffset :: Text -> (Int, Int) -> Text -> Text

-- | 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.
newtype PersistUnsafeMigrationException
PersistUnsafeMigrationException :: [(Bool, Sql)] -> PersistUnsafeMigrationException

-- | 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 Migration = WriterT [Text] WriterT CautiousMigration ReaderT SqlBackend IO ()

-- | 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 CautiousMigration = [(Bool, Sql)]
type Sql = Text

-- | 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 (Either [Text] CautiousMigration)

-- | Like parseMigration, but instead of returning the value in an
--   Either value, it calls error on the error values.
parseMigration' :: forall (m :: Type -> Type). (HasCallStack, MonadIO m) => Migration -> ReaderT SqlBackend m CautiousMigration

-- | Prints a migration.
printMigration :: forall (m :: Type -> Type). (HasCallStack, MonadIO m) => Migration -> ReaderT SqlBackend m ()

-- | Convert a Migration to a list of Text values
--   corresponding to their Sql statements.
showMigration :: forall (m :: Type -> Type). (HasCallStack, MonadIO m) => Migration -> ReaderT SqlBackend m [Text]

-- | Return all of the Sql values associated with the given
--   migration. Calls error if there's a parse error on any
--   migration.
getMigration :: forall (m :: Type -> Type). (MonadIO m, HasCallStack) => Migration -> ReaderT SqlBackend m [Sql]

-- | Runs a migration. If the migration fails to parse or if any of the
--   migrations are unsafe, then this throws a
--   PersistUnsafeMigrationException.
runMigration :: forall (m :: Type -> Type). MonadIO m => Migration -> ReaderT SqlBackend m ()

-- | 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
runMigrationQuiet :: forall (m :: Type -> Type). MonadIO 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!
runMigrationSilent :: forall (m :: Type -> Type). MonadUnliftIO m => Migration -> ReaderT SqlBackend m [Text]

-- | Like runMigration, but this will perform the unsafe database
--   migrations instead of erroring out.
runMigrationUnsafe :: forall (m :: Type -> Type). MonadIO m => Migration -> ReaderT SqlBackend m ()

-- | Same as runMigrationUnsafe, but returns a list of the SQL
--   commands executed instead of printing them to stderr.
runMigrationUnsafeQuiet :: forall (m :: Type -> Type). (HasCallStack, MonadIO m) => Migration -> ReaderT SqlBackend m [Text]

-- | Report multiple errors in a Migration.
reportErrors :: [Text] -> Migration

-- | Add a migration to the migration plan.
addMigration :: Bool -> Sql -> Migration

-- | Add a CautiousMigration (aka a [(Bool,
--   Text)]) to the migration plan.
addMigrations :: CautiousMigration -> 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";" []
--   
runSqlCommand :: SqlPersistT IO () -> Migration

-- | 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).
transactionSave :: forall (m :: Type -> Type). MonadIO m => ReaderT SqlBackend m ()

-- | Commit the current transaction and begin a new one with the specified
--   isolation level.
transactionSaveWithIsolation :: forall (m :: Type -> Type). MonadIO m => IsolationLevel -> 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.
transactionUndo :: forall (m :: Type -> Type). MonadIO m => ReaderT SqlBackend m ()

-- | Roll back the current transaction and begin a new one with the
--   specified isolation level.
transactionUndoWithIsolation :: forall (m :: Type -> Type). MonadIO m => IsolationLevel -> ReaderT SqlBackend m ()

-- | WARNING
--   
--   This module is introduced in version 3.5.0.0 to provide a
--   smooth migration experience from this legacy syntax to the new and
--   improved syntax. If you've imported this module, it means you've
--   decided to use the old syntax for a little bit longer, rather than
--   migrate to the new stuff. That's fine!
--   
--   But you should know that this module, and all of the legacy syntax,
--   will be completely removed from the library in version
--   4.0.0.0.
--   
--   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.
module Database.Esqueleto.Legacy

-- | WHERE clause: restrict the query's result.
where_ :: 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 `<a>InnerJoin</a>` 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 `<tt>CrossJoin</tt>` 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 `<a>InnerJoin</a>` bar `<a>InnerJoin</a>` 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 `<a>InnerJoin</a>` bar `<a>InnerJoin</a>` baz) -> do
--     on (foo ^. FooId ==. bar ^. BarFooId)
--     on (baz ^. BazId ==. bar ^. BarBazId)
--     ...
--   
on :: SqlExpr (Value Bool) -> SqlQuery ()

-- | GROUP BY clause. You can enclose multiple columns in a tuple.
--   
--   
--   select $ from \(foo `<tt>InnerJoin</tt>` 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 `<tt>InnerJoin</tt>` 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)
--   
groupBy :: ToSomeValues a => a -> SqlQuery ()

-- | ORDER BY clause. See also asc and desc.
--   
--   Multiple calls to orderBy get concatenated on the final query,
--   including distinctOnOrderBy.
orderBy :: [SqlExpr OrderBy] -> SqlQuery ()

-- | Ascending order of this field or SqlExpression.
asc :: PersistField a => SqlExpr (Value a) -> SqlExpr OrderBy

-- | Descending order of this field or SqlExpression.
desc :: PersistField a => SqlExpr (Value a) -> SqlExpr OrderBy

-- | LIMIT. Limit the number of returned rows.
limit :: Int64 -> SqlQuery ()

-- | OFFSET. Usually used with limit.
offset :: Int64 -> SqlQuery ()

-- | 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 ())
--     ...
--   
distinct :: 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.

-- | Deprecated: This function is deprecated, as it is only supported in
--   Postgresql. Please use the variant in PostgreSQL instead.
distinctOn :: [SqlExpr DistinctOn] -> SqlQuery a -> SqlQuery a

-- | Erase an SqlExpression's type so that it's suitable to be used by
--   distinctOn.
don :: SqlExpr (Value a) -> SqlExpr DistinctOn

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

-- | Deprecated: This function is deprecated, as it is only supported in
--   Postgresql. Please use the function defined in PostgreSQL
--   instead.
distinctOnOrderBy :: [SqlExpr OrderBy] -> SqlQuery a -> SqlQuery a

-- | HAVING.
having :: SqlExpr (Value Bool) -> 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.
locking :: LockingKind -> SqlQuery ()

-- | Project a field of an entity.
(^.) :: forall typ val. (PersistEntity val, PersistField typ) => SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
infixl 9 ^.

-- | Project an EntityField of a nullable entity. The result type
--   will be Nullable, meaning that nested Maybe won't be
--   produced here.
--   
--   As of v3.6.0.0, this will attempt to combine nested Maybe. If
--   you want to keep nested Maybe, then see ??..
(?.) :: (PersistEntity val, PersistField typ) => SqlExpr (Maybe (Entity val)) -> EntityField val typ -> SqlExpr (Value (Maybe (Nullable typ)))
infixl 9 ?.

-- | Lift a constant value from Haskell-land to the query.
val :: PersistField typ => typ -> SqlExpr (Value typ)

-- | 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:
--   
--   TODO: table
--   
--   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}
--   
isNothing :: PersistField typ => SqlExpr (Value (Maybe typ)) -> SqlExpr (Value Bool)

-- | Analogous to Just, promotes a value of type typ into
--   one of type Maybe typ. It should hold that val .
--   Just === just . val.
--   
--   This function will try not to produce a nested Maybe. This is
--   in accord with how SQL represents NULL. That means that
--   just . just = just. This behavior was
--   changed in v3.6.0.0. If you want to produce nested Maybe, see
--   just'.
just :: NullableFieldProjection typ typ' => SqlExpr (Value typ) -> SqlExpr (Value (Maybe typ'))

-- | Like just, but this function does not try to collapse nested
--   Maybe. This may be useful if you have type inference problems
--   with just.
just' :: SqlExpr (Value typ) -> SqlExpr (Value (Maybe typ))

-- | NULL value.
nothing :: SqlExpr (Value (Maybe typ))

-- | Join nested Maybes in a Value into one. This is useful
--   when calling aggregate functions on nullable fields.
--   
--   As of v3.6.0.0, this function will attempt to work on both
--   SqlExpr (Value (Maybe a)) as well as
--   SqlExpr (Value (Maybe (Maybe a)))
--   inputs to make transitioning to NullableFieldProjection easier.
--   This may make type inference worse in some cases. If you want the
--   monomorphic variant, see joinV'
joinV :: NullableFieldProjection typ typ' => SqlExpr (Value (Maybe typ)) -> SqlExpr (Value (Maybe typ'))

-- | Like joinV, but monomorphic: the input type only works on
--   SqlExpr (Value (Maybe (Maybe a))).
--   
--   This function may be useful if you have type inference issues with
--   joinV.
joinV' :: SqlExpr (Value (Maybe (Maybe typ))) -> SqlExpr (Value (Maybe typ))

-- | Project an SqlExpression that may be null, guarding against null
--   cases.
withNonNull :: PersistField typ => SqlExpr (Value (Maybe typ)) -> (SqlExpr (Value typ) -> SqlQuery a) -> SqlQuery a

-- | COUNT(*) value.
countRows :: Num a => SqlExpr (Value a)

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

-- | COUNT(DISTINCT x).
countDistinct :: Num a => SqlExpr (Value typ) -> SqlExpr (Value a)
not_ :: SqlExpr (Value Bool) -> SqlExpr (Value Bool)

-- | This operator produces the SQL operator =, which is used to
--   compare values for equality.
--   
--   Example:
--   
--   
--   query :: UserId -> SqlPersistT IO [Entity User]
--   query userId = select $ do
--       user <- from $ table @User
--       where_ (user ^. UserId ==. val userId)
--       pure user
--   
--   
--   This would generate the following SQL:
--   
--   
--   SELECT user.*
--   FROM user
--   WHERE user.id = ?
--   
(==.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 ==.

-- | This operator translates to the SQL operator >=.
--   
--   Example:
--   
--   
--   where_ $ user ^. UserAge >=. val 21
--   
(>=.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 >=.

-- | This operator translates to the SQL operator >.
--   
--   Example:
--   
--   
--   where_ $ user ^. UserAge >. val 20
--   
(>.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 >.

-- | This operator translates to the SQL operator <=.
--   
--   Example:
--   
--   
--   where_ $ val 21 <=. user ^. UserAge
--   
(<=.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 <=.

-- | This operator translates to the SQL operator <.
--   
--   Example:
--   
--   
--   where_ $ val 20 <. user ^. UserAge
--   
(<.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 <.

-- | This operator translates to the SQL operator !=.
--   
--   Example:
--   
--   
--   where_ $ user ^. UserName !=. val Bob
--   
(!=.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 !=.

-- | This operator translates to the SQL operator AND.
--   
--   Example:
--   
--   
--   where_ $
--           user ^. UserName ==. val Matt
--       &&. user ^. UserAge >=. val 21
--   
(&&.) :: SqlExpr (Value Bool) -> SqlExpr (Value Bool) -> SqlExpr (Value Bool)
infixr 3 &&.

-- | This operator translates to the SQL operator AND.
--   
--   Example:
--   
--   
--   where_ $
--           user ^. UserName ==. val Matt
--       ||. user ^. UserName ==. val John
--   
(||.) :: SqlExpr (Value Bool) -> SqlExpr (Value Bool) -> SqlExpr (Value Bool)
infixr 2 ||.

-- | a between (b, c) translates to the SQL expression
--   a >= b AND a <= c. It does not use a SQL
--   BETWEEN operator.
--   
--   @since: 3.1.0
between :: PersistField a => SqlExpr (Value a) -> (SqlExpr (Value a), SqlExpr (Value a)) -> SqlExpr (Value Bool)

-- | This operator translates to the SQL operator +.
--   
--   This does not require or assume anything about the SQL values.
--   Interpreting what +. means for a given type is left to the
--   database engine.
--   
--   Example:
--   
--   
--   user ^. UserAge +. val 10
--   
(+.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)
infixl 6 +.

-- | This operator translates to the SQL operator -.
--   
--   This does not require or assume anything about the SQL values.
--   Interpreting what -. means for a given type is left to the
--   database engine.
--   
--   Example:
--   
--   
--   user ^. UserAge -. val 10
--   
(-.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)
infixl 6 -.

-- | This operator translates to the SQL operator /.
--   
--   This does not require or assume anything about the SQL values.
--   Interpreting what /. means for a given type is left to the
--   database engine.
--   
--   Example:
--   
--   
--   user ^. UserAge /. val 10
--   
(/.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)
infixl 7 /.

-- | This operator translates to the SQL operator *.
--   
--   This does not require or assume anything about the SQL values.
--   Interpreting what *. means for a given type is left to the
--   database engine.
--   
--   Example:
--   
--   
--   user ^. UserAge *. val 10
--   
(*.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)
infixl 7 *.
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 (Nullable a)))
max_ :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value (Maybe (Nullable 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))

-- | 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.
castNum :: (Num a, Num b) => SqlExpr (Value a) -> SqlExpr (Value b)

-- | Same as castNum, but for nullable values.
castNumM :: (Num a, Num b) => SqlExpr (Value (Maybe a)) -> SqlExpr (Value (Maybe b))

-- | 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.
coalesce :: (PersistField a, NullableFieldProjection a a') => [SqlExpr (Value (Maybe a))] -> SqlExpr (Value (Maybe a'))

-- | Like coalesce, but takes a non-nullable SqlExpression placed
--   at the end of the SqlExpression list, which guarantees a non-NULL
--   result.
coalesceDefault :: PersistField a => [SqlExpr (Value (Maybe a))] -> SqlExpr (Value a) -> SqlExpr (Value a)

-- | LOWER function.
lower_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | UPPER function. @since 3.3.0
upper_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | TRIM function. @since 3.3.0
trim_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | LTRIM function. @since 3.3.0
ltrim_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | RTRIM function. @since 3.3.0
rtrim_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | LENGTH function. @since 3.3.0
length_ :: (SqlString s, Num a) => SqlExpr (Value s) -> SqlExpr (Value a)

-- | LEFT function. @since 3.3.0
left_ :: (SqlString s, Num a) => (SqlExpr (Value s), SqlExpr (Value a)) -> SqlExpr (Value s)

-- | RIGHT function. @since 3.3.0
right_ :: (SqlString s, Num a) => (SqlExpr (Value s), SqlExpr (Value a)) -> SqlExpr (Value s)

-- | LIKE operator.
like :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s) -> SqlExpr (Value Bool)
infixr 2 `like`

-- | ILIKE operator (case-insensitive LIKE).
--   
--   Supported by PostgreSQL only. Deprecated in version 3.6.0 in favor of
--   the version available from Database.Esqueleto.PostgreSQL.

-- | Deprecated: Since 3.6.0: ilike is only supported on
--   Postgres. Please import it from 'Database.Esqueleto.PostgreSQL.
ilike :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s) -> SqlExpr (Value Bool)
infixr 2 `ilike`

-- | 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 `<a>like</a>` (%) ++. val "John" ++. (%)
--   
(%) :: SqlString s => SqlExpr (Value s)

-- | The CONCAT function with a variable number of parameters.
--   Supported by MySQL and PostgreSQL. SQLite supports this in versions
--   after 3.44.0, and persistent-sqlite supports this in versions
--   2.13.3.0 and after.
concat_ :: SqlString s => [SqlExpr (Value s)] -> SqlExpr (Value s)

-- | The || string concatenation operator (named after Haskell's
--   ++ in order to avoid naming clash with ||.).
--   
--   Supported by SQLite and PostgreSQL.
--   
--   MySQL support requires setting the SQL mode to
--   PIPES_AS_CONCAT or ANSI - see this StackOverflow
--   answer.
(++.) :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s) -> SqlExpr (Value s)
infixr 5 ++.

-- | 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.
castString :: (SqlString s, SqlString r) => SqlExpr (Value s) -> SqlExpr (Value r)

-- | Execute a subquery SELECT in an SqlExpression. Returns a list
--   of values.
subList_select :: PersistField a => SqlQuery (SqlExpr (Value a)) -> SqlExpr (ValueList a)

-- | Lift a list of constant value from Haskell-land to the query.
valList :: PersistField typ => [typ] -> SqlExpr (ValueList 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.
justList :: SqlExpr (ValueList typ) -> SqlExpr (ValueList (Maybe typ))

-- | 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 `<tt>in_</tt>` valList personIds
--   return person
--   
--   
--   Where personIds is of type [Key Person].
in_ :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (ValueList typ) -> SqlExpr (Value Bool)

-- | NOT IN operator.
notIn :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (ValueList typ) -> SqlExpr (Value Bool)

-- | EXISTS operator. For example:
--   
--   
--   select $
--   from $ \person -> do
--   where_ $ exists $
--            from $ \post -> do
--            where_ (post ^. BlogPostAuthorId ==. person ^. PersonId)
--   return person
--   
exists :: SqlQuery () -> SqlExpr (Value Bool)

-- | NOT EXISTS operator.
notExists :: SqlQuery () -> SqlExpr (Value Bool)

-- | 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.
set :: PersistEntity val => SqlExpr (Entity val) -> [SqlExpr (Entity val) -> SqlExpr Update] -> SqlQuery ()
(=.) :: (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 statement. For example:
--   
--   
--   select $
--   return $
--   case_
--      [ when_
--          (exists $
--          from $ \p -> do
--          where_ (p ^. PersonName ==. val "Mike"))
--        then_
--          (subSelect $
--          from $ \v -> do
--          let sub =
--                  from $ \c -> do
--                  where_ (c ^. PersonName ==. val "Mike")
--                  return (c ^. PersonFavNum)
--          where_ (just (v ^. PersonFavNum) >. subSelect 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.
--   
case_ :: PersistField a => [(SqlExpr (Value Bool), SqlExpr (Value a))] -> SqlExpr (Value a) -> SqlExpr (Value a)

-- | 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 `<tt>InnerJoin</tt>` 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.
toBaseId :: ToBaseId ent => SqlExpr (Value (Key ent)) -> SqlExpr (Value (Key (BaseEnt ent)))

-- | The inverse of toBaseId. Note that this is somewhat less "safe"
--   than toBaseId. Calling toBaseId will usually mean that a
--   foreign key constraint is present that guarantees the presence of the
--   base ID. fromBaseId has no such guarantee. Consider the code
--   example given in toBaseId:
--   
--   
--   Bar
--     barNum Int
--   Foo
--     bar BarId
--     fooNum Int
--     Primary bar
--   
--   
--   
--   instance ToBaseId Foo where
--     type BaseEnt Foo = Bar
--     toBaseIdWitness barId = FooKey barId
--   
--   
--   The type of toBaseId for Foo would be:
--   
--   
--   toBaseId :: SqlExpr (Value FooId) -> SqlExpr (Value BarId)
--   
--   
--   The foreign key constraint on Foo means that every
--   FooId points to a BarId in the database. However,
--   fromBaseId will not have this:
--   
--   
--   fromBaseId :: SqlExpr (Value BarId) -> SqlExpr (Value FooId)
--   
fromBaseId :: ToBaseId ent => SqlExpr (Value (Key (BaseEnt ent))) -> SqlExpr (Value (Key ent))

-- | As fromBaseId, but works on Maybe keys.
fromBaseIdMaybe :: ToBaseId ent => SqlExpr (Value (Maybe (Key (BaseEnt ent)))) -> SqlExpr (Value (Maybe (Key ent)))

-- | Like toBaseId, but works on Maybe keys.
toBaseIdMaybe :: ToBaseId ent => SqlExpr (Value (Maybe (Key ent))) -> SqlExpr (Value (Maybe (Key (BaseEnt ent))))

-- | 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.
subSelect :: (PersistField a, NullableFieldProjection a a') => SqlQuery (SqlExpr (Value 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).
subSelectMaybe :: PersistField a => SqlQuery (SqlExpr (Value (Maybe a))) -> SqlExpr (Value (Maybe 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.
subSelectCount :: (Num a, PersistField a) => SqlQuery ignored -> 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)
--   
subSelectForeign :: (BackendCompatible SqlBackend (PersistEntityBackend val1), PersistEntity val1, PersistEntity val2, PersistField a) => SqlExpr (Entity val2) -> EntityField val2 (Key val1) -> (SqlExpr (Entity val1) -> SqlExpr (Value a)) -> SqlExpr (Value 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.
subSelectList :: PersistField a => SqlQuery (SqlExpr (Value a)) -> SqlExpr (ValueList a)

-- | Execute a subquery SELECT in a SqlExpr. This function
--   is unsafe, because it can throw runtime exceptions in two cases:
--   
--   
--   
- 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.
--   
- 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.
subSelectUnsafe :: PersistField a => SqlQuery (SqlExpr (Value a)) -> SqlExpr (Value a)

-- | Class that enables one to use toBaseId to convert an entity's
--   key on a query into another (cf. toBaseId).
class ToBaseId ent where {
    
    -- | e.g. <tt>type BaseEnt MyBase = MyChild</tt>
    type BaseEnt 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.
toBaseIdWitness :: ToBaseId ent => Key (BaseEnt ent) -> Key ent

-- | Syntax sugar for case_.
when_ :: expr (Value Bool) -> () -> expr a -> (expr (Value Bool), expr a)

-- | Syntax sugar for case_.
then_ :: ()

-- | Syntax sugar for case_.
else_ :: expr a -> expr a

-- | 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 `<a>LeftOuterJoin</a>` mb) -> ...
--   from $ \(p1 `<a>InnerJoin</a>` f `<a>InnerJoin</a>` p2) -> ...
--   from $ \((p1 `<a>InnerJoin</a>` f) `<a>InnerJoin</a>` 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 `<a>LeftOuterJoin</a>` mb)
--     :: (...) => InnerJoin (expr (Entity Person)) (expr (Maybe (Entity BlogPost)))
--   (p1 `<a>InnerJoin</a>` f `<a>InnerJoin</a>` p2)
--     :: (...) => InnerJoin
--                   (InnerJoin (expr (Entity Person))
--                              (expr (Entity Follow)))
--                   (expr (Entity Person))
--   (p1 `<a>InnerJoin</a>` (f `<a>InnerJoin</a>` p2)) ::
--     :: (...) => InnerJoin
--                   (expr (Entity Person))
--                   (InnerJoin (expr (Entity Follow))
--                              (expr (Entity Person)))
--   
--   
--   Note that some backends may not support all kinds of JOINs.
from :: From a => (a -> SqlQuery b) -> SqlQuery b

-- | A single value (as opposed to a whole entity). You may use
--   (^.) or (?.) to get a Value
--   from an Entity.
newtype Value a
Value :: a -> Value a
[unValue] :: Value a -> 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).
newtype ValueList a
ValueList :: a -> ValueList a

-- | Phantom type used by orderBy, asc and desc.
data OrderBy

-- | Phantom type used by distinctOn and don.
data DistinctOn

-- | 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.
data LockingKind

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

-- | Deprecated: The constructors for LockingKind are deprecated
--   in v3.6.0.0. Instead, please refer to the smart constructors
--   forUpdate and forUpdateSkipLocked.
ForUpdate :: LockingKind

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

-- | Deprecated: The constructors for LockingKind are deprecated
--   in v3.6.0.0. Instead, please refer to the smart constructors
--   forUpdate and forUpdateSkipLocked.
ForUpdateSkipLocked :: LockingKind

-- | FOR SHARE syntax. Supported by PostgreSQL.

-- | Deprecated: The constructors for LockingKind are deprecated
--   in v3.6.0.0. Instead, please refer to the smart constructor
--   forShare exported from Database.Esqueleto.PostgreSQL.
ForShare :: LockingKind

-- | LOCK IN SHARE MODE syntax. Supported by MySQL.

-- | Deprecated: The constructors for LockingKind are deprecated
--   in v3.6.0.0. Instead, please refer to the smart constructors
--   lockInShareMode exported from Database.Esqueleto.MySQL.
LockInShareMode :: LockingKind

-- | FOR UPDATE syntax.
--   
--   Usage:
--   
--   
--   locking forUpdate
--   
forUpdate :: LockingKind

-- | FOR UPDATE SKIP LOCKED syntax.
--   
--   
--   locking forUpdateSkipLocked
--   
forUpdateSkipLocked :: LockingKind

-- | 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
--   
class LockableEntity a
flattenLockableEntity :: LockableEntity a => a -> NonEmpty LockableSqlExpr

-- | 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.
class PersistField a => SqlString a

-- | Data type that represents an INNER JOIN (see
--   LeftOuterJoin for an example).
data InnerJoin a b
InnerJoin :: a -> b -> InnerJoin a b
infixl 2 `InnerJoin`
infixl 2 `InnerJoin`

-- | Data type that represents a CROSS JOIN (see
--   LeftOuterJoin for an example).
data CrossJoin a b
CrossJoin :: a -> b -> CrossJoin a b
infixl 2 `CrossJoin`
infixl 2 `CrossJoin`

-- | Data type that represents a LEFT OUTER JOIN. For example,
--   
--   
--   select $
--   from $ \(person `<tt>LeftOuterJoin</tt>` pet) ->
--     ...
--   
--   
--   is translated into
--   
--   
--   SELECT ...
--   FROM Person LEFT OUTER JOIN Pet
--   ...
--   
--   
--   See also: from.
data LeftOuterJoin a b
LeftOuterJoin :: a -> b -> LeftOuterJoin a b
infixl 2 `LeftOuterJoin`
infixl 2 `LeftOuterJoin`

-- | Data type that represents a RIGHT OUTER JOIN (see
--   LeftOuterJoin for an example).
data RightOuterJoin a b
RightOuterJoin :: a -> b -> RightOuterJoin a b
infixl 2 `RightOuterJoin`
infixl 2 `RightOuterJoin`

-- | Data type that represents a FULL OUTER JOIN (see
--   LeftOuterJoin for an example).
data FullOuterJoin a b
FullOuterJoin :: a -> b -> FullOuterJoin a b
infixl 2 `FullOuterJoin`
infixl 2 `FullOuterJoin`

-- | (Internal) A kind of JOIN.
data JoinKind

-- | 
--   INNER JOIN
--   
InnerJoinKind :: JoinKind

-- | 
--   CROSS JOIN
--   
CrossJoinKind :: JoinKind

-- | 
--   LEFT OUTER JOIN
--   
LeftOuterJoinKind :: JoinKind

-- | 
--   RIGHT OUTER JOIN
--   
RightOuterJoinKind :: JoinKind

-- | 
--   FULL OUTER JOIN
--   
FullOuterJoinKind :: JoinKind

-- | Exception thrown whenever on is used to create an ON
--   clause but no matching JOIN is found.
data OnClauseWithoutMatchingJoinException
OnClauseWithoutMatchingJoinException :: String -> OnClauseWithoutMatchingJoinException

-- | SQL backend for esqueleto using SqlPersistT.
data SqlQuery 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.
data SqlExpr a

-- | Constraint synonym for persistent entities whose backend is
--   SqlBackend.
type SqlEntity ent = (PersistEntity ent, PersistEntityBackend ent ~ SqlBackend)

-- | 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).
select :: forall a r (m :: Type -> Type) backend. (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 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
--   
selectOne :: forall a r (m :: Type -> Type) backend. (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 a
--   Source of rows.
selectSource :: forall a r backend (m :: Type -> Type). (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 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)
--   
delete :: forall (m :: Type -> Type) backend. (MonadIO m, SqlBackendCanWrite backend) => SqlQuery () -> ReaderT backend m ()

-- | Same as delete, but returns the number of rows affected.
deleteCount :: forall (m :: Type -> Type) backend. (MonadIO m, SqlBackendCanWrite backend) => SqlQuery () -> ReaderT backend m Int64

-- | 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)
--   
update :: forall (m :: Type -> Type) val backend. (MonadIO m, PersistEntity val, BackendCompatible SqlBackend (PersistEntityBackend val), SqlBackendCanWrite backend) => (SqlExpr (Entity val) -> SqlQuery ()) -> ReaderT backend m ()

-- | Same as update, but returns the number of rows affected.
updateCount :: forall (m :: Type -> Type) val backend. (MonadIO m, PersistEntity val, BackendCompatible SqlBackend (PersistEntityBackend val), SqlBackendCanWrite backend) => (SqlExpr (Entity val) -> SqlQuery ()) -> ReaderT backend m Int64

-- | Insert a PersistField for every selected value.
insertSelect :: forall (m :: Type -> Type) a backend. (MonadIO m, PersistEntity a, SqlBackendCanWrite backend) => SqlQuery (SqlExpr (Insertion a)) -> ReaderT backend m ()

-- | Insert a PersistField for every selected value, return the
--   count afterward
insertSelectCount :: forall (m :: Type -> Type) a backend. (MonadIO m, PersistEntity a, SqlBackendCanWrite backend) => SqlQuery (SqlExpr (Insertion a)) -> ReaderT backend m Int64

-- | Apply a PersistField constructor to SqlExpr Value
--   arguments.
(<#) :: (a -> b) -> SqlExpr (Value a) -> SqlExpr (Insertion b)

-- | Apply extra SqlExpr Value arguments to a PersistField
--   constructor
(<&>) :: SqlExpr (Insertion (a -> b)) -> SqlExpr (Value a) -> SqlExpr (Insertion b)

-- | 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.
renderQueryToText :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => Mode -> SqlQuery a -> 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.
renderQuerySelect :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => SqlQuery a -> 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.
renderQueryUpdate :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => SqlQuery a -> 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.
renderQueryDelete :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => SqlQuery a -> 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.
renderQueryInsertInto :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => SqlQuery a -> ReaderT backend m (Text, [PersistValue])

-- | (Internal) Class that implements the tuple from magic (see
--   fromStart).
class From a

-- | valkey i = val . toSqlKey
--   (https://github.com/prowdsponsor/esqueleto/issues/9).
valkey :: (ToBackendKey SqlBackend entity, PersistField (Key entity)) => Int64 -> 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).
valJ :: PersistField (Key entity) => Value (Key entity) -> SqlExpr (Value (Key entity))

-- | 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.
associateJoin :: forall e1 e0. Ord (Key e0) => [(Entity e0, e1)] -> Map (Key e0) (e0, [e1])

-- | Synonym for delete that does not clash with
--   esqueleto's delete.
deleteKey :: forall backend val (m :: Type -> Type). (PersistStore backend, BaseBackend backend ~ PersistEntityBackend val, MonadIO m, PersistEntity val) => Key val -> ReaderT backend m ()

-- | 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.
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 allows multiple different backends (databases).
    type PersistEntityBackend record;
    
    -- | By default, a backend will automatically generate the key Instead you
    --   can specify a Primary key made up of unique values.
    data Key record;
    
    -- | An <a>EntityField</a> is parameterised by the Haskell record it
    --   belongs to and the additional type of that field.
    --   
    --   As of <tt>persistent-2.11.0.0</tt>, it's possible to use the
    --   <tt>OverloadedLabels</tt> language extension to refer to
    --   <a>EntityField</a> values polymorphically. See the documentation on
    --   <a>SymbolToField</a> for more information.
    data EntityField record :: Type -> Type;
    
    -- | Unique keys besides the <a>Key</a>.
    data Unique record;
}

-- | A lower-level key operation.
keyToValues :: PersistEntity record => Key record -> [PersistValue]

-- | A lower-level key operation.
keyFromValues :: PersistEntity record => [PersistValue] -> Either Text (Key record)

-- | A meta-operation to retrieve the Key EntityField.
persistIdField :: PersistEntity record => EntityField record (Key record)

-- | Retrieve the EntityDef meta-data for the record.
entityDef :: PersistEntity record => proxy record -> EntityDef

-- | Return meta-data for a given EntityField.
persistFieldDef :: PersistEntity record => EntityField record typ -> FieldDef

-- | A meta-operation to get the database fields of a record.
toPersistFields :: PersistEntity record => record -> [PersistValue]

-- | A lower-level operation to convert from database values to a Haskell
--   record.
fromPersistValues :: PersistEntity record => [PersistValue] -> Either Text 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
--   
tabulateEntityA :: (PersistEntity record, Applicative f) => (forall a. () => EntityField record a -> f a) -> f (Entity record)

-- | Like tabulateEntityA, but works with any Apply f. This
--   works because all entities have at least one field, and so we can
--   tabulate things into semigroup-like shapes instead.
tabulateEntityApply :: (PersistEntity record, Apply f) => (forall a. () => EntityField record a -> f a) -> f (Entity record)

-- | A meta operation to retrieve all the Unique keys.
persistUniqueKeys :: PersistEntity record => record -> [Unique record]

-- | A lower level operation.
persistUniqueToFieldNames :: PersistEntity record => Unique record -> NonEmpty (FieldNameHS, FieldNameDB)

-- | A lower level operation.
persistUniqueToValues :: PersistEntity record => Unique record -> [PersistValue]

-- | Use a PersistField as a lens.
fieldLens :: PersistEntity record => EntityField record field -> forall (f :: Type -> Type). Functor f => (field -> f field) -> Entity record -> f (Entity 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.
keyFromRecordM :: PersistEntity record => Maybe (record -> Key record)

-- | By default, a backend will automatically generate the key Instead you
--   can specify a Primary key made up of unique values.
data family Key record
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

-- | 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). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Key record)

-- | 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   |
--   +-----+------+-----+
--   
insert_ :: forall record (m :: Type -> Type). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m ()

-- | 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). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => [record] -> ReaderT backend m [Key record]

-- | 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   |
--   +-----+------+-----+
--   
insertMany_ :: forall record (m :: Type -> Type). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => [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   |
--   +-----+------+-----+
--   
insertEntityMany :: forall record (m :: Type -> Type). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend) => [Entity 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   |
--   +-----+------+-----+
--   
insertKey :: forall record (m :: Type -> Type). (PersistStoreWrite backend, 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  |
--   +-----+------+-----+
--   
repsert :: forall record (m :: Type -> Type). (PersistStoreWrite backend, 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      |
--   +-----+----------------+---------+
--   
repsertMany :: forall record (m :: Type -> Type). (PersistStoreWrite backend, 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   |
--   +-----+------+-----+
--   
replace :: forall record (m :: Type -> Type). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend) => Key record -> record -> ReaderT backend m ()

-- | 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   |
--   +-----+------+-----+
--   
updateGet :: forall record (m :: Type -> Type). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend) => Key record -> [Update record] -> ReaderT backend m record
data PersistFilter
Eq :: PersistFilter
Ne :: PersistFilter
Gt :: PersistFilter
Lt :: PersistFilter
Ge :: PersistFilter
Le :: PersistFilter
In :: PersistFilter
NotIn :: PersistFilter
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

-- | 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 |
--   +------+-----+
--   
get :: forall record (m :: Type -> Type). (PersistStoreRead backend, MonadIO m, PersistRecordBackend record backend) => Key record -> ReaderT backend m (Maybe 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 |
--   +----+-------+-----+
--   
getMany :: forall record (m :: Type -> Type). (PersistStoreRead backend, MonadIO m, PersistRecordBackend record backend) => [Key record] -> ReaderT backend m (Map (Key record) record)

-- | 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.
--   
class (PersistUniqueRead backend, PersistStoreWrite backend) => PersistUniqueWrite backend

-- | 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   |
--   +-----+------+-----+
--   
deleteBy :: forall record (m :: Type -> Type). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m ()

-- | 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). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Maybe (Key record))

-- | 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.
insertUnique_ :: forall record (m :: Type -> Type). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Maybe ())

-- | 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.
upsert :: forall record (m :: Type -> Type). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend, OnlyOneUniqueKey record, SafeToInsert record) => record -> [Update record] -> ReaderT backend m (Entity record)

-- | 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  |
--   +-----+-----+-----+
--   
upsertBy :: forall record (m :: Type -> Type). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => Unique record -> record -> [Update record] -> ReaderT backend m (Entity record)

-- | Put many records into db
--   
--   
--   
- insert new records that do not exist (or violate any unique
--   constraints)
--   
- replace existing records (matching any unique constraint)
--   
putMany :: forall record (m :: Type -> Type). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => [record] -> ReaderT backend m ()

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

-- | 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.
migrate :: [EntityDef] -> EntityDef -> Migration

-- | Report a single error in a Migration.
reportError :: Text -> Migration

-- | Unique keys besides the Key.
data family Unique record

-- | A single column (see rawSql). Any PersistField may
--   be used here, including PersistValue (which does not do any
--   processing).
newtype Single a
Single :: a -> Single a
[unSingle] :: Single a -> a
data Column
Column :: !FieldNameDB -> !Bool -> !SqlType -> !Maybe Text -> !Maybe Text -> !Maybe ConstraintNameDB -> !Maybe Integer -> !Maybe ColumnReference -> Column
[cName] :: Column -> !FieldNameDB
[cNull] :: Column -> !Bool
[cSqlType] :: Column -> !SqlType
[cDefault] :: Column -> !Maybe Text
[cGenerated] :: Column -> !Maybe Text
[cDefaultConstraintName] :: Column -> !Maybe ConstraintNameDB
[cMaxLen] :: Column -> !Maybe Integer
[cReference] :: Column -> !Maybe ColumnReference

-- | 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)
--   
rawSql :: forall a (m :: Type -> Type) backend. (RawSql a, MonadIO m, BackendCompatible SqlBackend backend) => Text -> [PersistValue] -> ReaderT backend m [a]

-- | 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.
class PersistConfig c where {
    type PersistConfigBackend c :: Type -> Type -> Type -> Type;
    type PersistConfigPool c;
}

-- | Load the config settings from a Value, most likely taken from a
--   YAML config file.
loadConfig :: PersistConfig c => Value -> Parser c

-- | Modify the config settings based on environment variables.
applyEnv :: PersistConfig c => c -> IO c

-- | Create a new connection pool based on the given config settings.
createPoolConfig :: PersistConfig c => c -> IO (PersistConfigPool c)

-- | Run a database action by taking a connection from the pool.
runPool :: (PersistConfig c, MonadUnliftIO m) => c -> PersistConfigBackend c m a -> PersistConfigPool c -> m a
type family PersistConfigBackend c :: Type -> Type -> Type -> Type
type family PersistConfigPool c

-- | An ConstraintNameHS represents the Haskell-side name that
--   persistent will use for a constraint.
newtype ConstraintNameHS
ConstraintNameHS :: Text -> ConstraintNameHS
[unConstraintNameHS] :: ConstraintNameHS -> Text

-- | A ConstraintNameDB represents the datastore-side name that
--   persistent will use for a constraint.
newtype ConstraintNameDB
ConstraintNameDB :: Text -> ConstraintNameDB
[unConstraintNameDB] :: ConstraintNameDB -> Text

-- | An EntityNameDB represents the datastore-side name that
--   persistent will use for an entity.
newtype EntityNameDB
EntityNameDB :: Text -> EntityNameDB
[unEntityNameDB] :: EntityNameDB -> Text

-- | An EntityNameHS represents the Haskell-side name that
--   persistent will use for an entity.
newtype EntityNameHS
EntityNameHS :: Text -> EntityNameHS
[unEntityNameHS] :: EntityNameHS -> Text

-- | A FieldNameHS represents the Haskell-side name that
--   persistent will use for a field.
newtype FieldNameHS
FieldNameHS :: Text -> FieldNameHS
[unFieldNameHS] :: FieldNameHS -> Text

-- | A FieldNameDB represents the datastore-side name that
--   persistent will use for a field.
newtype FieldNameDB
FieldNameDB :: Text -> FieldNameDB
[unFieldNameDB] :: FieldNameDB -> Text

-- | Convenience operations for working with '-NameDB' types.
class DatabaseName a
escapeWith :: DatabaseName a => (Text -> str) -> a -> str

-- | A type that determines how a backend should handle the literal.
data LiteralType

-- | The accompanying value will be escaped before inserting into the
--   database. This is the correct default choice to use.
Escaped :: LiteralType

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

-- | 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.
DbSpecific :: LiteralType

-- | A raw value which can be stored in any backend and can be marshalled
--   to and from a PersistField.
data PersistValue
PersistText :: Text -> PersistValue
PersistByteString :: ByteString -> PersistValue
PersistInt64 :: Int64 -> PersistValue
PersistDouble :: Double -> PersistValue
PersistRational :: Rational -> PersistValue
PersistBool :: Bool -> PersistValue
PersistDay :: Day -> PersistValue
PersistTimeOfDay :: TimeOfDay -> PersistValue
PersistUTCTime :: UTCTime -> PersistValue
PersistNull :: PersistValue
PersistList :: [PersistValue] -> PersistValue
PersistMap :: [(Text, PersistValue)] -> PersistValue

-- | Intended especially for MongoDB backend
PersistObjectId :: ByteString -> PersistValue

-- | Intended especially for PostgreSQL backend for text arrays
PersistArray :: [PersistValue] -> PersistValue

-- | 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.
PersistLiteral_ :: LiteralType -> 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.
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.
pattern PersistLiteralEscaped :: 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.
pattern PersistDbSpecific :: ByteString -> PersistValue
fromPersistValueText :: PersistValue -> Either Text Text

-- | Please refer to the documentation for the database in question for a
--   full overview of the semantics of the varying isolation levels
data IsolationLevel
ReadUncommitted :: IsolationLevel
ReadCommitted :: IsolationLevel
RepeatableRead :: IsolationLevel
Serializable :: IsolationLevel

-- | 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.
data FieldDef
FieldDef :: !FieldNameHS -> !FieldNameDB -> !FieldType -> !SqlType -> ![FieldAttr] -> !Bool -> !ReferenceDef -> !FieldCascade -> !Maybe Text -> !Maybe Text -> !Bool -> FieldDef

-- | 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.
[fieldHaskell] :: FieldDef -> !FieldNameHS

-- | The name of the field in the database. For SQL databases, this
--   corresponds to the column name.
[fieldDB] :: FieldDef -> !FieldNameDB

-- | The type of the field in Haskell.
[fieldType] :: FieldDef -> !FieldType

-- | The type of the field in a SQL database.
[fieldSqlType] :: FieldDef -> !SqlType

-- | User annotations for a field. These are provided with the !
--   operator.
[fieldAttrs] :: FieldDef -> ![FieldAttr]

-- | If this is True, then the Haskell datatype will have a strict
--   record field. The default value for this is True.
[fieldStrict] :: FieldDef -> !Bool
[fieldReference] :: FieldDef -> !ReferenceDef

-- | 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.
[fieldCascade] :: FieldDef -> !FieldCascade

-- | Optional comments for a Field.
[fieldComments] :: FieldDef -> !Maybe Text

-- | Whether or not the field is a GENERATED column, and
--   additionally the expression to use for generation.
[fieldGenerated] :: FieldDef -> !Maybe Text

-- | True if the field is an implicit ID column. False
--   otherwise.
[fieldIsImplicitIdColumn] :: FieldDef -> !Bool
data PersistUpdate
Assign :: PersistUpdate
Add :: PersistUpdate
Subtract :: PersistUpdate
Multiply :: PersistUpdate
Divide :: PersistUpdate
BackendSpecificUpdate :: Text -> PersistUpdate
type family BackendSpecificUpdate backend record
data UpdateException
KeyNotFound :: String -> UpdateException
UpsertError :: String -> UpdateException

-- | 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.
data SqlType
SqlString :: SqlType
SqlInt32 :: SqlType
SqlInt64 :: SqlType
SqlReal :: SqlType
SqlNumeric :: Word32 -> Word32 -> SqlType
SqlBool :: SqlType
SqlDay :: SqlType
SqlTime :: SqlType

-- | Always uses UTC timezone
SqlDayTime :: SqlType
SqlBlob :: SqlType

-- | a backend-specific name
SqlOther :: Text -> SqlType
data PersistException

-- | Generic Exception
PersistError :: Text -> PersistException
PersistMarshalError :: Text -> PersistException
PersistInvalidField :: Text -> PersistException
PersistForeignConstraintUnmet :: Text -> PersistException
PersistMongoDBError :: Text -> PersistException
PersistMongoDBUnsupported :: Text -> PersistException

-- | An action that might happen on a deletion or update on a foreign key
--   change.
data CascadeAction
Cascade :: CascadeAction
Restrict :: CascadeAction
SetNull :: CascadeAction
SetDefault :: CascadeAction

-- | 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.
data FieldCascade
FieldCascade :: !Maybe CascadeAction -> !Maybe CascadeAction -> FieldCascade
[fcOnUpdate] :: FieldCascade -> !Maybe CascadeAction
[fcOnDelete] :: FieldCascade -> !Maybe CascadeAction
data ForeignDef
ForeignDef :: !EntityNameHS -> !EntityNameDB -> !ConstraintNameHS -> !ConstraintNameDB -> !FieldCascade -> ![(ForeignFieldDef, ForeignFieldDef)] -> ![Attr] -> Bool -> Bool -> ForeignDef
[foreignRefTableHaskell] :: ForeignDef -> !EntityNameHS
[foreignRefTableDBName] :: ForeignDef -> !EntityNameDB
[foreignConstraintNameHaskell] :: ForeignDef -> !ConstraintNameHS
[foreignConstraintNameDBName] :: ForeignDef -> !ConstraintNameDB

-- | Determine how the field will cascade on updates and deletions.
[foreignFieldCascade] :: ForeignDef -> !FieldCascade
[foreignFields] :: ForeignDef -> ![(ForeignFieldDef, ForeignFieldDef)]
[foreignAttrs] :: ForeignDef -> ![Attr]
[foreignNullable] :: ForeignDef -> Bool

-- | Determines if the reference is towards a Primary Key or not.
[foreignToPrimary] :: ForeignDef -> Bool

-- | Used instead of FieldDef to generate a smaller amount of code
type ForeignFieldDef = (FieldNameHS, FieldNameDB)
data CompositeDef
CompositeDef :: !NonEmpty FieldDef -> ![Attr] -> CompositeDef
[compositeFields] :: CompositeDef -> !NonEmpty FieldDef
[compositeAttrs] :: CompositeDef -> ![Attr]

-- | 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 = []
--       }
--   
data UniqueDef
UniqueDef :: !ConstraintNameHS -> !ConstraintNameDB -> !NonEmpty (FieldNameHS, FieldNameDB) -> ![Attr] -> UniqueDef
[uniqueHaskell] :: UniqueDef -> !ConstraintNameHS
[uniqueDBName] :: UniqueDef -> !ConstraintNameDB
[uniqueFields] :: UniqueDef -> !NonEmpty (FieldNameHS, FieldNameDB)
[uniqueAttrs] :: UniqueDef -> ![Attr]

-- | An EmbedFieldDef is the same as a FieldDef But it is only used for
--   embeddedFields so it only has data needed for embedding
data EmbedFieldDef
EmbedFieldDef :: FieldNameDB -> Maybe (Either SelfEmbed EntityNameHS) -> EmbedFieldDef
[emFieldDB] :: EmbedFieldDef -> FieldNameDB
[emFieldEmbed] :: EmbedFieldDef -> Maybe (Either SelfEmbed EntityNameHS)

-- | An EmbedEntityDef is the same as an EntityDef But it is only used for
--   fieldReference so it only has data needed for embedding
data EmbedEntityDef
EmbedEntityDef :: EntityNameHS -> [EmbedFieldDef] -> EmbedEntityDef
[embeddedHaskell] :: EmbedEntityDef -> EntityNameHS
[embeddedFields] :: EmbedEntityDef -> [EmbedFieldDef]

-- | There are 3 kinds of references 1) composite (to fields that exist in
--   the record) 2) single field 3) embedded
data ReferenceDef
NoReference :: ReferenceDef

-- | 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
ForeignRef :: !EntityNameHS -> ReferenceDef
EmbedRef :: EntityNameHS -> ReferenceDef

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

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

-- | Optional module and name.
FTTypeCon :: Maybe Text -> Text -> FieldType
FTLit :: FieldTypeLit -> FieldType
FTTypePromoted :: Text -> FieldType
FTApp :: FieldType -> FieldType -> FieldType
FTList :: FieldType -> FieldType

-- | 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.
data FieldAttr

-- | 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
--   
FieldAttrMaybe :: FieldAttr

-- | 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
--   
FieldAttrNullable :: FieldAttr

-- | 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
--   
FieldAttrMigrationOnly :: FieldAttr

-- | 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
--   
FieldAttrSafeToRemove :: FieldAttr

-- | 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
--   
FieldAttrNoreference :: FieldAttr

-- | 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.
FieldAttrReference :: Text -> FieldAttr

-- | 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"
--   
FieldAttrConstraint :: Text -> FieldAttr

-- | 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.
FieldAttrDefault :: Text -> FieldAttr

-- | 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
--   
FieldAttrSqltype :: Text -> FieldAttr

-- | Set a maximum length for a column. Useful for VARCHAR and indexes.
--   
--   
--   User
--       name     Text    maxlen=200
--   
--       UniqueName name
--   
FieldAttrMaxlen :: Integer -> FieldAttr

-- | 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.
FieldAttrSql :: Text -> FieldAttr

-- | A grab bag of random attributes that were unrecognized by the parser.
FieldAttrOther :: Text -> FieldAttr
type Attr = Text
type ExtraLine = [Text]

-- | The definition for the entity's primary key ID.
data EntityIdDef

-- | The entity has a single key column, and it is a surrogate key - that
--   is, you can't go from rec -> Key rec.
EntityIdField :: !FieldDef -> EntityIdDef

-- | 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.
EntityIdNaturalKey :: !CompositeDef -> EntityIdDef

-- | 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.
data EntityDef

-- | 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.
data WhyNullable
ByMaybeAttr :: WhyNullable
ByNullableAttr :: WhyNullable
data IsNullable
Nullable :: !WhyNullable -> IsNullable
NotNullable :: IsNullable

-- | 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.
data Checkmark

-- | When used on a uniqueness constraint, there may be at most one
--   Active record.
Active :: Checkmark

-- | When used on a uniqueness constraint, there may be any number of
--   Inactive records.
Inactive :: Checkmark
fieldAttrsContainsNullable :: [FieldAttr] -> IsNullable

-- | Return the [FieldDef] for the entity keys.
entitiesPrimary :: EntityDef -> NonEmpty FieldDef
entityPrimary :: EntityDef -> Maybe CompositeDef

-- | Returns a NonEmpty list of FieldDef that correspond with
--   the key columns for an EntityDef.
keyAndEntityFields :: EntityDef -> NonEmpty FieldDef

-- | Returns a NonEmpty list of FieldDef that correspond with
--   the key columns for an 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 fields on the Haskell type use keyAndEntityFieldsDatabase
keyAndEntityFieldsDatabase :: EntityDef -> NonEmpty FieldDef

-- | Parse raw field attributes into structured form. Any unrecognized
--   attributes will be preserved, identically as they are encountered, as
--   FieldAttrOther values.
parseFieldAttrs :: [Text] -> [FieldAttr]
isFieldNotGenerated :: FieldDef -> Bool

-- | Returns True if the FieldDef does not have a
--   MigrationOnly or SafeToRemove flag from the
--   QuasiQuoter.
isHaskellField :: FieldDef -> Bool

-- | A FieldCascade that does nothing.
noCascade :: FieldCascade

-- | Renders a FieldCascade value such that it can be used in SQL
--   migrations.
renderFieldCascade :: FieldCascade -> Text

-- | Render a CascadeAction to Text such that it can be used
--   in a SQL command.
renderCascadeAction :: CascadeAction -> Text

-- | A Statement is a representation of a database query that has
--   been prepared and stored on the server side.
data Statement
Statement :: IO () -> IO () -> ([PersistValue] -> IO Int64) -> (forall (m :: Type -> Type). MonadIO m => [PersistValue] -> Acquire (ConduitM () [PersistValue] m ())) -> Statement
[stmtFinalize] :: Statement -> IO ()
[stmtReset] :: Statement -> IO ()
[stmtExecute] :: Statement -> [PersistValue] -> IO Int64
[stmtQuery] :: Statement -> forall (m :: Type -> Type). MonadIO m => [PersistValue] -> Acquire (ConduitM () [PersistValue] m ())
data InsertSqlResult
ISRSingle :: Text -> InsertSqlResult
ISRInsertGet :: Text -> Text -> InsertSqlResult
ISRManyKeys :: Text -> [PersistValue] -> InsertSqlResult
type LogFunc = Loc -> LogSource -> LogLevel -> LogStr -> IO ()

-- | Replace the FieldDef FieldAttr with the new list.
setFieldAttrs :: [FieldAttr] -> FieldDef -> FieldDef

-- | Modify the list of field attributes.
overFieldAttrs :: ([FieldAttr] -> [FieldAttr]) -> FieldDef -> FieldDef

-- | Add an attribute to the list of field attributes.
addFieldAttr :: FieldAttr -> FieldDef -> FieldDef

-- | Check if the field definition is nullable
isFieldNullable :: FieldDef -> IsNullable

-- | Check if the field is `Maybe a`
isFieldMaybe :: FieldDef -> Bool

-- | 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.
getEntityUniquesNoPrimaryKey :: 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.
getEntityUniques :: EntityDef -> [UniqueDef]

-- | Retrieve the Haskell name of the given entity.
getEntityHaskellName :: EntityDef -> EntityNameHS

-- | Return the database name for the given entity.
getEntityDBName :: EntityDef -> EntityNameDB
getEntityExtra :: EntityDef -> Map Text [[Text]]

setEntityDBName :: EntityNameDB -> EntityDef -> EntityDef
getEntityComments :: EntityDef -> Maybe Text

getEntityForeignDefs :: EntityDef -> [ForeignDef]

-- | 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.
getEntityFields :: 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.
getEntityFieldsDatabase :: EntityDef -> [FieldDef]

isEntitySum :: EntityDef -> Bool

getEntityId :: EntityDef -> EntityIdDef

getEntityIdField :: EntityDef -> Maybe FieldDef

-- | Set an entityId to be the given FieldDef.
setEntityId :: FieldDef -> EntityDef -> EntityDef

setEntityIdDef :: EntityIdDef -> EntityDef -> EntityDef

getEntityKeyFields :: EntityDef -> NonEmpty FieldDef

-- | Perform a mapping function over all of the entity fields, as
--   determined by getEntityFieldsDatabase.
overEntityFields :: ([FieldDef] -> [FieldDef]) -> EntityDef -> EntityDef

-- | Gets the Source of the definition of the entity.
--   
--   Note that as of this writing the span covers the entire file or
--   quasiquote where the item is defined due to parsing limitations. This
--   may be changed in a future release to be more accurate.
getEntitySpan :: EntityDef -> Maybe SourceSpan

-- | 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.
newtype OverflowNatural
OverflowNatural :: Natural -> OverflowNatural
[unOverflowNatural] :: OverflowNatural -> Natural

-- | 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 Text
--    deriving (Eq, Show, PersistFieldSql)
--   
--   mkSSN :: Text -> Either Text 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.
--   
class PersistField a
toPersistValue :: PersistField a => a -> PersistValue
fromPersistValue :: PersistField a => PersistValue -> Either Text 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.
class SafeToInsert a

-- | 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.
class SymbolToField (sym :: Symbol) rec typ | sym rec -> typ
symbolToField :: SymbolToField sym rec typ => EntityField rec typ

-- | 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.
data Entity record
Entity :: Key record -> record -> Entity record
[entityKey] :: Entity record -> Key record
[entityVal] :: Entity record -> record

-- | Value to filter with. Highly dependant on the type of filter used.
data FilterValue typ
[FilterValue] :: forall typ. typ -> FilterValue typ
[FilterValues] :: forall typ. [typ] -> FilterValue typ
[UnsafeValue] :: forall a typ. PersistField a => a -> FilterValue typ

-- | Persistent allows multiple different backends (databases).
type family PersistEntityBackend record

-- | 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 family EntityField record :: Type -> Type

-- | 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.
tabulateEntity :: PersistEntity record => (forall a. () => EntityField record a -> a) -> Entity record

-- | Get list of values corresponding to given entity.
entityValues :: PersistEntity record => Entity record -> [PersistValue]

-- | Predefined toJSON. The resulting JSON looks like {"key":
--   1, "value": {"name": ...}}.
--   
--   The typical usage is:
--   
--   
--   instance ToJSON (Entity User) where
--       toJSON = keyValueEntityToJSON
--   
keyValueEntityToJSON :: (PersistEntity record, ToJSON record) => Entity record -> Value

-- | Predefined parseJSON. The input JSON looks like {"key":
--   1, "value": {"name": ...}}.
--   
--   The typical usage is:
--   
--   
--   instance FromJSON (Entity User) where
--       parseJSON = keyValueEntityFromJSON
--   
keyValueEntityFromJSON :: (PersistEntity record, FromJSON record) => Value -> Parser (Entity record)

-- | Predefined toJSON. The resulting JSON looks like {"id":
--   1, "name": ...}.
--   
--   The typical usage is:
--   
--   
--   instance ToJSON (Entity User) where
--       toJSON = entityIdToJSON
--   
entityIdToJSON :: (PersistEntity record, ToJSON record) => Entity record -> Value

-- | Predefined parseJSON. The input JSON looks like {"id": 1,
--   "name": ...}.
--   
--   The typical usage is:
--   
--   
--   instance FromJSON (Entity User) where
--       parseJSON = entityIdFromJSON
--   
entityIdFromJSON :: (PersistEntity record, FromJSON record) => Value -> Parser (Entity record)

-- | 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
--   
toPersistValueJSON :: ToJSON a => a -> PersistValue

-- | 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
--   
fromPersistValueJSON :: FromJSON a => PersistValue -> Either Text a
class PersistCore backend where {
    data BackendKey backend;
}
data family BackendKey backend

-- | 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.
class (PersistEntity record, PersistEntityBackend record ~ backend, PersistCore backend) => ToBackendKey backend record
toBackendKey :: ToBackendKey backend record => Key record -> BackendKey backend
fromBackendKey :: ToBackendKey backend record => BackendKey backend -> Key record

-- | A convenient alias for common type signatures
type PersistRecordBackend record backend = (PersistEntity record, PersistEntityBackend record ~ BaseBackend backend)

-- | 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
--   
class BackendCompatible sup sub
projectBackend :: BackendCompatible sup sub => sub -> sup

-- | 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.
class HasPersistBackend backend => IsPersistBackend backend

-- | 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 
class HasPersistBackend backend where {
    type BaseBackend backend;
}
persistBackend :: HasPersistBackend backend => backend -> BaseBackend backend
type family BaseBackend backend

-- | 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.
withBaseBackend :: forall backend (m :: Type -> Type) a. HasPersistBackend backend => ReaderT (BaseBackend backend) m a -> ReaderT backend 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.
withCompatibleBackend :: forall sup sub (m :: Type -> Type) a. BackendCompatible sup sub => ReaderT sup m a -> ReaderT sub m a
liftPersist :: (MonadIO m, MonadReader backend m) => ReaderT backend IO b -> m b

-- | 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.
getJust :: forall record backend (m :: Type -> Type). (PersistStoreRead backend, PersistRecordBackend record backend, MonadIO m) => Key record -> ReaderT backend m 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 |
--   +----+------+-----+
--   
getJustEntity :: forall record backend (m :: Type -> Type). (PersistEntityBackend record ~ BaseBackend backend, MonadIO m, PersistEntity record, PersistStoreRead backend) => Key record -> ReaderT backend m (Entity record)

-- | Curry this to make a convenience function that loads an associated
--   model.
--   
--   
--   foreign = belongsTo foreignId
--   
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)

-- | Same as belongsTo, but uses getJust and therefore is
--   similarly unsafe.
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

-- | 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 |
--   +----+---------+-----+
--   
insertEntity :: forall e backend (m :: Type -> Type). (PersistStoreWrite backend, PersistRecordBackend e backend, SafeToInsert e, MonadIO m, HasCallStack) => e -> ReaderT backend m (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 |
--   +----+------+-----+
--   
getEntity :: forall e backend (m :: Type -> Type). (PersistStoreRead backend, PersistRecordBackend e backend, MonadIO m) => Key e -> ReaderT backend m (Maybe (Entity e))

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

-- | 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.
data SqlBackend

-- | 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.
class PersistEntity record => AtLeastOneUniqueKey record
requireUniquesP :: AtLeastOneUniqueKey record => record -> NonEmpty (Unique record)

-- | This is an error message. It is used when an entity has multiple
--   unique keys, and the function expects a single unique key.
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 writing instances of
--   OnlyOneUniqueKey for an entity that has no unique keys.
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 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.
class PersistEntity record => OnlyOneUniqueKey record
onlyUniqueP :: OnlyOneUniqueKey record => record -> Unique record

-- | 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.
class PersistStoreRead backend => PersistUniqueRead backend

-- | 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 |
--   +----+------+-----+
--   
getBy :: forall record (m :: Type -> Type). (PersistUniqueRead backend, MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m (Maybe (Entity record))

-- | 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.
existsBy :: forall record (m :: Type -> Type). (PersistUniqueRead backend, MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m Bool

-- | Given a proxy for a PersistEntity record, this returns the sole
--   UniqueDef for that entity.
onlyOneUniqueDef :: (OnlyOneUniqueKey record, Monad proxy) => proxy record -> UniqueDef

-- | 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 |
--   +----+-------+-----+
--   
insertUniqueEntity :: forall record backend (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, PersistUniqueWrite backend, SafeToInsert record) => record -> ReaderT backend m (Maybe (Entity 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.
onlyUnique :: forall record backend (m :: Type -> Type). (MonadIO m, PersistUniqueWrite backend, PersistRecordBackend record backend, OnlyOneUniqueKey record) => record -> ReaderT backend m (Unique 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 |
--   +----+------+-----+
--   
getByValue :: forall record (m :: Type -> Type) backend. (MonadIO m, PersistUniqueRead backend, PersistRecordBackend record backend, AtLeastOneUniqueKey record) => record -> ReaderT backend m (Maybe (Entity 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
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))

-- | 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
--   
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 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
--   
checkUniqueUpdateable :: forall record backend (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, PersistUniqueRead backend) => Entity record -> ReaderT backend m (Maybe (Unique record))

-- | Backends supporting conditional write operations
class (PersistQueryRead backend, PersistStoreWrite backend) => PersistQueryWrite backend

-- | Update individual fields on any record matching the given criterion.
updateWhere :: forall (m :: Type -> Type) record. (PersistQueryWrite backend, MonadIO m, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> ReaderT backend m ()

-- | Delete all records matching the given criterion.
deleteWhere :: forall (m :: Type -> Type) record. (PersistQueryWrite backend, MonadIO m, PersistRecordBackend record backend) => [Filter record] -> ReaderT backend m ()

-- | Backends supporting conditional read operations.
class (PersistCore backend, PersistStoreRead backend) => PersistQueryRead backend

-- | 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.
selectSourceRes :: forall record (m1 :: Type -> Type) (m2 :: Type -> Type). (PersistQueryRead backend, PersistRecordBackend record backend, MonadIO m1, MonadIO m2) => [Filter record] -> [SelectOpt record] -> ReaderT backend m1 (Acquire (ConduitM () (Entity record) m2 ()))

-- | Get just the first record for the criterion.
selectFirst :: forall (m :: Type -> Type) record. (PersistQueryRead backend, MonadIO m, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))

-- | Get the Keys of all records matching the given criterion.
selectKeysRes :: forall (m1 :: Type -> Type) (m2 :: Type -> Type) record. (PersistQueryRead backend, 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.
--   
--   For an example, see selectList.
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 ()

-- | 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 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 backend which is a wrapper around SqlBackend.
type IsSqlBackend backend = (IsPersistBackend backend, BaseBackend backend ~ SqlBackend)

-- | Like SqlPersistT but compatible with any SQL backend which
--   can handle read and write queries.
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 queries.
type SqlReadT (m :: Type -> Type) a = forall backend. SqlBackendCanRead backend => ReaderT backend m a

-- | A constraint synonym which witnesses that a backend is SQL and can run
--   read and write 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 queries.
type SqlBackendCanRead backend = (BackendCompatible SqlBackend backend, PersistQueryRead backend, PersistStoreRead backend, PersistUniqueRead backend)

-- | An SQL backend which can handle read or write queries
--   
--   The constructor was exposed in 2.10.0
newtype SqlWriteBackend
SqlWriteBackend :: SqlBackend -> SqlWriteBackend
[unSqlWriteBackend] :: SqlWriteBackend -> SqlBackend

-- | An SQL backend which can only handle read queries
--   
--   The constructor was exposed in 2.10.0.
newtype SqlReadBackend
SqlReadBackend :: SqlBackend -> SqlReadBackend
[unSqlReadBackend] :: SqlReadBackend -> SqlBackend

-- | Useful for running a write query against an untagged backend with
--   unknown capabilities.
writeToUnknown :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlWriteBackend m a -> ReaderT SqlBackend m a

-- | Useful for running a read query against a backend with read and write
--   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 unknown
--   capabilities.
readToUnknown :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlReadBackend m a -> ReaderT SqlBackend m a

-- | Values to configure a pool of database connections. See
--   Data.Pool for details.
data ConnectionPoolConfig
ConnectionPoolConfig :: Int -> NominalDiffTime -> Int -> ConnectionPoolConfig

-- | How many stripes to divide the pool into. See Data.Pool for
--   details. Default: 1.
[connectionPoolConfigStripes] :: ConnectionPoolConfig -> Int

-- | How long connections can remain idle before being disposed of, in
--   seconds. Default: 600
[connectionPoolConfigIdleTimeout] :: ConnectionPoolConfig -> NominalDiffTime

-- | How many connections should be held in the connection pool. Default:
--   10
[connectionPoolConfigSize] :: ConnectionPoolConfig -> Int
type ConnectionPool = Pool SqlBackend
type SqlPersistM = SqlPersistT NoLoggingT ResourceT IO
type SqlPersistT = ReaderT SqlBackend
data PersistentSqlException
StatementAlreadyFinalized :: Text -> PersistentSqlException
Couldn'tGetSQLConnection :: PersistentSqlException

-- | This value specifies how a field references another table.
data ColumnReference
ColumnReference :: !EntityNameDB -> !ConstraintNameDB -> !FieldCascade -> ColumnReference

-- | The table name that the
[crTableName] :: ColumnReference -> !EntityNameDB

-- | The name of the foreign key constraint.
[crConstraintName] :: ColumnReference -> !ConstraintNameDB

-- | Whether or not updates/deletions to the referenced table cascade to
--   this table.
[crFieldCascade] :: ColumnReference -> !FieldCascade

-- | Initializes a ConnectionPoolConfig with default values. See the
--   documentation of ConnectionPoolConfig for each field's default
--   value.
defaultConnectionPoolConfig :: ConnectionPoolConfig

-- | 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.
data BackendSpecificOverrides

-- | 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
getBackendSpecificForeignKeyName :: BackendSpecificOverrides -> Maybe (EntityNameDB -> FieldNameDB -> ConstraintNameDB)

-- | Set the backend's foreign key generation function to this value.
setBackendSpecificForeignKeyName :: (EntityNameDB -> FieldNameDB -> ConstraintNameDB) -> BackendSpecificOverrides -> BackendSpecificOverrides

-- | Creates an empty BackendSpecificOverrides (i.e. use the default
--   behavior; no overrides)
emptyBackendSpecificOverrides :: BackendSpecificOverrides
defaultAttribute :: [FieldAttr] -> Maybe Text

-- | Create the list of columns for the given entity.
mkColumns :: [EntityDef] -> EntityDef -> BackendSpecificOverrides -> ([Column], [UniqueDef], [ForeignDef])

-- | A more general way to convert instances of ToJSON type class to
--   strict text Text.
toJsonText :: ToJSON j => j -> Text

-- | 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"
--   
class PersistField a => PersistFieldSql a
sqlType :: PersistFieldSql a => Proxy a -> SqlType

-- | 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.
newtype EntityWithPrefix (prefix :: Symbol) record
EntityWithPrefix :: Entity record -> EntityWithPrefix (prefix :: Symbol) record
[unEntityWithPrefix] :: EntityWithPrefix (prefix :: Symbol) record -> Entity record

-- | Class for data types that may be retrived from a rawSql
--   query.
class RawSql a

-- | Number of columns that this data type needs and the list of
--   substitutions for SELECT placeholders ??.
rawSqlCols :: RawSql a => (Text -> Text) -> a -> (Int, [Text])

-- | A string telling the user why the column count is what it is.
rawSqlColCountReason :: RawSql a => a -> String

-- | Transform a row of the result into the data type.
rawSqlProcessRow :: RawSql a => [PersistValue] -> Either Text a

-- | 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"
--   
unPrefix :: forall (prefix :: Symbol) record. EntityWithPrefix prefix record -> Entity record
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 ()))

-- | Execute a raw SQL statement
rawExecute :: forall (m :: Type -> Type) backend. (MonadIO m, BackendCompatible SqlBackend backend) => Text -> [PersistValue] -> ReaderT backend m ()

-- | Execute a raw SQL statement and return the number of rows it has
--   modified.
rawExecuteCount :: forall (m :: Type -> Type) backend. (MonadIO m, BackendCompatible SqlBackend backend) => Text -> [PersistValue] -> ReaderT backend m Int64
getStmtConn :: SqlBackend -> Text -> IO Statement

-- | 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.
runSqlPool :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> m a

-- | Like runSqlPool, but supports specifying an isolation level.
runSqlPoolWithIsolation :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> IsolationLevel -> m a

-- | Like runSqlPool, but does not surround the action in a
--   transaction. This action might leave your database in a weird state.
runSqlPoolNoTransaction :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> 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.
runSqlPoolWithHooks :: forall backend m a before after onException. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> (backend -> m before) -> (backend -> m after) -> (backend -> SomeException -> m onException) -> m a

-- | This function is how runSqlPoolWithHooks is defined.
--   
--   It's currently the most general function for using a SQL pool.
runSqlPoolWithExtensibleHooks :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> SqlPoolHooks m backend -> m a

-- | 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.
acquireSqlConn :: (MonadReader backend m, BackendCompatible SqlBackend backend) => m (Acquire backend)

-- | Like acquireSqlConn, but lets you specify an explicit isolation
--   level.
acquireSqlConnWithIsolation :: (MonadReader backend m, BackendCompatible SqlBackend backend) => IsolationLevel -> m (Acquire backend)
runSqlConn :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> backend -> m a

-- | Like runSqlConn, but supports specifying an isolation level.
runSqlConnWithIsolation :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> backend -> IsolationLevel -> m a
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 :: forall backend m a. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> Int -> (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.
withSqlPoolWithConfig :: forall backend m a. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> ConnectionPoolConfig -> (Pool backend -> m a) -> m a
createSqlPool :: forall backend m. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> Int -> m (Pool backend)

-- | Creates a pool of connections to a SQL database.
createSqlPoolWithConfig :: (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> ConnectionPoolConfig -> m (Pool backend)

-- | 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}}]
--   
withSqlConn :: forall backend m a. (MonadUnliftIO m, MonadLoggerIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> (backend -> m a) -> m a
close' :: BackendCompatible SqlBackend backend => backend -> IO ()
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

-- | 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
getTableName :: forall record (m :: Type -> Type) backend. (PersistEntity record, BackendCompatible SqlBackend backend, Monad m) => record -> ReaderT backend m Text

-- | useful for a backend to implement tableName by adding escaping
tableDBName :: PersistEntity record => record -> EntityNameDB

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

-- | useful for a backend to implement fieldName by adding escaping
fieldDBName :: PersistEntity record => EntityField record typ -> FieldNameDB

-- | Used when determining how to prefix a column name in a WHERE
--   clause.
data FilterTablePrefix

-- | Prefix the column with the table name. This is useful if the column
--   name might be ambiguous.
PrefixTableName :: FilterTablePrefix

-- | 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.
PrefixExcluded :: FilterTablePrefix

-- | Render a [Filter record] into a Text value
--   suitable for inclusion into a SQL query.
filterClause :: PersistEntity val => Maybe FilterTablePrefix -> SqlBackend -> [Filter val] -> Text

-- | 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.
filterClauseWithVals :: PersistEntity val => Maybe FilterTablePrefix -> SqlBackend -> [Filter val] -> (Text, [PersistValue])

-- | Render a [SelectOpt record] made up *only* of
--   Asc and Desc constructors into a Text value
--   suitable for inclusion into a SQL query.
orderClause :: PersistEntity val => Maybe FilterTablePrefix -> SqlBackend -> [SelectOpt val] -> Text

-- | Generates sql for limit and offset for postgres, sqlite and mysql.
decorateSQLWithLimitOffset :: Text -> (Int, Int) -> Text -> Text

-- | 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.
newtype PersistUnsafeMigrationException
PersistUnsafeMigrationException :: [(Bool, Sql)] -> PersistUnsafeMigrationException

-- | 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 Migration = WriterT [Text] WriterT CautiousMigration ReaderT SqlBackend IO ()

-- | 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 CautiousMigration = [(Bool, Sql)]
type Sql = Text

-- | 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 (Either [Text] CautiousMigration)

-- | Like parseMigration, but instead of returning the value in an
--   Either value, it calls error on the error values.
parseMigration' :: forall (m :: Type -> Type). (HasCallStack, MonadIO m) => Migration -> ReaderT SqlBackend m CautiousMigration

-- | Prints a migration.
printMigration :: forall (m :: Type -> Type). (HasCallStack, MonadIO m) => Migration -> ReaderT SqlBackend m ()

-- | Convert a Migration to a list of Text values
--   corresponding to their Sql statements.
showMigration :: forall (m :: Type -> Type). (HasCallStack, MonadIO m) => Migration -> ReaderT SqlBackend m [Text]

-- | Return all of the Sql values associated with the given
--   migration. Calls error if there's a parse error on any
--   migration.
getMigration :: forall (m :: Type -> Type). (MonadIO m, HasCallStack) => Migration -> ReaderT SqlBackend m [Sql]

-- | Runs a migration. If the migration fails to parse or if any of the
--   migrations are unsafe, then this throws a
--   PersistUnsafeMigrationException.
runMigration :: forall (m :: Type -> Type). MonadIO m => Migration -> ReaderT SqlBackend m ()

-- | 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
runMigrationQuiet :: forall (m :: Type -> Type). MonadIO 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!
runMigrationSilent :: forall (m :: Type -> Type). MonadUnliftIO m => Migration -> ReaderT SqlBackend m [Text]

-- | Like runMigration, but this will perform the unsafe database
--   migrations instead of erroring out.
runMigrationUnsafe :: forall (m :: Type -> Type). MonadIO m => Migration -> ReaderT SqlBackend m ()

-- | Same as runMigrationUnsafe, but returns a list of the SQL
--   commands executed instead of printing them to stderr.
runMigrationUnsafeQuiet :: forall (m :: Type -> Type). (HasCallStack, MonadIO m) => Migration -> ReaderT SqlBackend m [Text]

-- | Report multiple errors in a Migration.
reportErrors :: [Text] -> Migration

-- | Add a migration to the migration plan.
addMigration :: Bool -> Sql -> Migration

-- | Add a CautiousMigration (aka a [(Bool,
--   Text)]) to the migration plan.
addMigrations :: CautiousMigration -> 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";" []
--   
runSqlCommand :: SqlPersistT IO () -> Migration

-- | 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).
transactionSave :: forall (m :: Type -> Type). MonadIO m => ReaderT SqlBackend m ()

-- | Commit the current transaction and begin a new one with the specified
--   isolation level.
transactionSaveWithIsolation :: forall (m :: Type -> Type). MonadIO m => IsolationLevel -> 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.
transactionUndo :: forall (m :: Type -> Type). MonadIO m => ReaderT SqlBackend m ()

-- | Roll back the current transaction and begin a new one with the
--   specified isolation level.
transactionUndoWithIsolation :: forall (m :: Type -> Type). MonadIO m => IsolationLevel -> ReaderT SqlBackend m ()

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

-- | 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.
module Database.Esqueleto

-- | WHERE clause: restrict the query's result.
where_ :: 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 `<a>InnerJoin</a>` 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 `<tt>CrossJoin</tt>` 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 `<a>InnerJoin</a>` bar `<a>InnerJoin</a>` 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 `<a>InnerJoin</a>` bar `<a>InnerJoin</a>` baz) -> do
--     on (foo ^. FooId ==. bar ^. BarFooId)
--     on (baz ^. BazId ==. bar ^. BarBazId)
--     ...
--   
on :: SqlExpr (Value Bool) -> SqlQuery ()

-- | GROUP BY clause. You can enclose multiple columns in a tuple.
--   
--   
--   select $ from \(foo `<tt>InnerJoin</tt>` 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 `<tt>InnerJoin</tt>` 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)
--   
groupBy :: ToSomeValues a => a -> SqlQuery ()

-- | ORDER BY clause. See also asc and desc.
--   
--   Multiple calls to orderBy get concatenated on the final query,
--   including distinctOnOrderBy.
orderBy :: [SqlExpr OrderBy] -> SqlQuery ()

-- | Ascending order of this field or SqlExpression.
asc :: PersistField a => SqlExpr (Value a) -> SqlExpr OrderBy

-- | Descending order of this field or SqlExpression.
desc :: PersistField a => SqlExpr (Value a) -> SqlExpr OrderBy

-- | LIMIT. Limit the number of returned rows.
limit :: Int64 -> SqlQuery ()

-- | OFFSET. Usually used with limit.
offset :: Int64 -> SqlQuery ()

-- | 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 ())
--     ...
--   
distinct :: 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.

-- | Deprecated: This function is deprecated, as it is only supported in
--   Postgresql. Please use the variant in PostgreSQL instead.
distinctOn :: [SqlExpr DistinctOn] -> SqlQuery a -> SqlQuery a

-- | Erase an SqlExpression's type so that it's suitable to be used by
--   distinctOn.
don :: SqlExpr (Value a) -> SqlExpr DistinctOn

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

-- | Deprecated: This function is deprecated, as it is only supported in
--   Postgresql. Please use the function defined in PostgreSQL
--   instead.
distinctOnOrderBy :: [SqlExpr OrderBy] -> SqlQuery a -> SqlQuery a

-- | HAVING.
having :: SqlExpr (Value Bool) -> 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.
locking :: LockingKind -> SqlQuery ()

-- | Project a field of an entity.
(^.) :: forall typ val. (PersistEntity val, PersistField typ) => SqlExpr (Entity val) -> EntityField val typ -> SqlExpr (Value typ)
infixl 9 ^.

-- | Project an EntityField of a nullable entity. The result type
--   will be Nullable, meaning that nested Maybe won't be
--   produced here.
--   
--   As of v3.6.0.0, this will attempt to combine nested Maybe. If
--   you want to keep nested Maybe, then see ??..
(?.) :: (PersistEntity val, PersistField typ) => SqlExpr (Maybe (Entity val)) -> EntityField val typ -> SqlExpr (Value (Maybe (Nullable typ)))
infixl 9 ?.

-- | Lift a constant value from Haskell-land to the query.
val :: PersistField typ => typ -> SqlExpr (Value typ)

-- | 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:
--   
--   TODO: table
--   
--   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}
--   
isNothing :: PersistField typ => SqlExpr (Value (Maybe typ)) -> SqlExpr (Value Bool)

-- | Analogous to Just, promotes a value of type typ into
--   one of type Maybe typ. It should hold that val .
--   Just === just . val.
--   
--   This function will try not to produce a nested Maybe. This is
--   in accord with how SQL represents NULL. That means that
--   just . just = just. This behavior was
--   changed in v3.6.0.0. If you want to produce nested Maybe, see
--   just'.
just :: NullableFieldProjection typ typ' => SqlExpr (Value typ) -> SqlExpr (Value (Maybe typ'))

-- | Like just, but this function does not try to collapse nested
--   Maybe. This may be useful if you have type inference problems
--   with just.
just' :: SqlExpr (Value typ) -> SqlExpr (Value (Maybe typ))

-- | NULL value.
nothing :: SqlExpr (Value (Maybe typ))

-- | Join nested Maybes in a Value into one. This is useful
--   when calling aggregate functions on nullable fields.
--   
--   As of v3.6.0.0, this function will attempt to work on both
--   SqlExpr (Value (Maybe a)) as well as
--   SqlExpr (Value (Maybe (Maybe a)))
--   inputs to make transitioning to NullableFieldProjection easier.
--   This may make type inference worse in some cases. If you want the
--   monomorphic variant, see joinV'
joinV :: NullableFieldProjection typ typ' => SqlExpr (Value (Maybe typ)) -> SqlExpr (Value (Maybe typ'))

-- | Like joinV, but monomorphic: the input type only works on
--   SqlExpr (Value (Maybe (Maybe a))).
--   
--   This function may be useful if you have type inference issues with
--   joinV.
joinV' :: SqlExpr (Value (Maybe (Maybe typ))) -> SqlExpr (Value (Maybe typ))

-- | Project an SqlExpression that may be null, guarding against null
--   cases.
withNonNull :: PersistField typ => SqlExpr (Value (Maybe typ)) -> (SqlExpr (Value typ) -> SqlQuery a) -> SqlQuery a

-- | COUNT(*) value.
countRows :: Num a => SqlExpr (Value a)

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

-- | COUNT(DISTINCT x).
countDistinct :: Num a => SqlExpr (Value typ) -> SqlExpr (Value a)
not_ :: SqlExpr (Value Bool) -> SqlExpr (Value Bool)

-- | This operator produces the SQL operator =, which is used to
--   compare values for equality.
--   
--   Example:
--   
--   
--   query :: UserId -> SqlPersistT IO [Entity User]
--   query userId = select $ do
--       user <- from $ table @User
--       where_ (user ^. UserId ==. val userId)
--       pure user
--   
--   
--   This would generate the following SQL:
--   
--   
--   SELECT user.*
--   FROM user
--   WHERE user.id = ?
--   
(==.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 ==.

-- | This operator translates to the SQL operator >=.
--   
--   Example:
--   
--   
--   where_ $ user ^. UserAge >=. val 21
--   
(>=.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 >=.

-- | This operator translates to the SQL operator >.
--   
--   Example:
--   
--   
--   where_ $ user ^. UserAge >. val 20
--   
(>.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 >.

-- | This operator translates to the SQL operator <=.
--   
--   Example:
--   
--   
--   where_ $ val 21 <=. user ^. UserAge
--   
(<=.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 <=.

-- | This operator translates to the SQL operator <.
--   
--   Example:
--   
--   
--   where_ $ val 20 <. user ^. UserAge
--   
(<.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 <.

-- | This operator translates to the SQL operator !=.
--   
--   Example:
--   
--   
--   where_ $ user ^. UserName !=. val Bob
--   
(!=.) :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (Value typ) -> SqlExpr (Value Bool)
infix 4 !=.

-- | This operator translates to the SQL operator AND.
--   
--   Example:
--   
--   
--   where_ $
--           user ^. UserName ==. val Matt
--       &&. user ^. UserAge >=. val 21
--   
(&&.) :: SqlExpr (Value Bool) -> SqlExpr (Value Bool) -> SqlExpr (Value Bool)
infixr 3 &&.

-- | This operator translates to the SQL operator AND.
--   
--   Example:
--   
--   
--   where_ $
--           user ^. UserName ==. val Matt
--       ||. user ^. UserName ==. val John
--   
(||.) :: SqlExpr (Value Bool) -> SqlExpr (Value Bool) -> SqlExpr (Value Bool)
infixr 2 ||.

-- | a between (b, c) translates to the SQL expression
--   a >= b AND a <= c. It does not use a SQL
--   BETWEEN operator.
--   
--   @since: 3.1.0
between :: PersistField a => SqlExpr (Value a) -> (SqlExpr (Value a), SqlExpr (Value a)) -> SqlExpr (Value Bool)

-- | This operator translates to the SQL operator +.
--   
--   This does not require or assume anything about the SQL values.
--   Interpreting what +. means for a given type is left to the
--   database engine.
--   
--   Example:
--   
--   
--   user ^. UserAge +. val 10
--   
(+.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)
infixl 6 +.

-- | This operator translates to the SQL operator -.
--   
--   This does not require or assume anything about the SQL values.
--   Interpreting what -. means for a given type is left to the
--   database engine.
--   
--   Example:
--   
--   
--   user ^. UserAge -. val 10
--   
(-.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)
infixl 6 -.

-- | This operator translates to the SQL operator /.
--   
--   This does not require or assume anything about the SQL values.
--   Interpreting what /. means for a given type is left to the
--   database engine.
--   
--   Example:
--   
--   
--   user ^. UserAge /. val 10
--   
(/.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)
infixl 7 /.

-- | This operator translates to the SQL operator *.
--   
--   This does not require or assume anything about the SQL values.
--   Interpreting what *. means for a given type is left to the
--   database engine.
--   
--   Example:
--   
--   
--   user ^. UserAge *. val 10
--   
(*.) :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value a) -> SqlExpr (Value a)
infixl 7 *.
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 (Nullable a)))
max_ :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value (Maybe (Nullable 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))

-- | 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.
castNum :: (Num a, Num b) => SqlExpr (Value a) -> SqlExpr (Value b)

-- | Same as castNum, but for nullable values.
castNumM :: (Num a, Num b) => SqlExpr (Value (Maybe a)) -> SqlExpr (Value (Maybe b))

-- | 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.
coalesce :: (PersistField a, NullableFieldProjection a a') => [SqlExpr (Value (Maybe a))] -> SqlExpr (Value (Maybe a'))

-- | Like coalesce, but takes a non-nullable SqlExpression placed
--   at the end of the SqlExpression list, which guarantees a non-NULL
--   result.
coalesceDefault :: PersistField a => [SqlExpr (Value (Maybe a))] -> SqlExpr (Value a) -> SqlExpr (Value a)

-- | LOWER function.
lower_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | UPPER function. @since 3.3.0
upper_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | TRIM function. @since 3.3.0
trim_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | LTRIM function. @since 3.3.0
ltrim_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | RTRIM function. @since 3.3.0
rtrim_ :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s)

-- | LENGTH function. @since 3.3.0
length_ :: (SqlString s, Num a) => SqlExpr (Value s) -> SqlExpr (Value a)

-- | LEFT function. @since 3.3.0
left_ :: (SqlString s, Num a) => (SqlExpr (Value s), SqlExpr (Value a)) -> SqlExpr (Value s)

-- | RIGHT function. @since 3.3.0
right_ :: (SqlString s, Num a) => (SqlExpr (Value s), SqlExpr (Value a)) -> SqlExpr (Value s)

-- | LIKE operator.
like :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s) -> SqlExpr (Value Bool)
infixr 2 `like`

-- | ILIKE operator (case-insensitive LIKE).
--   
--   Supported by PostgreSQL only. Deprecated in version 3.6.0 in favor of
--   the version available from Database.Esqueleto.PostgreSQL.

-- | Deprecated: Since 3.6.0: ilike is only supported on
--   Postgres. Please import it from 'Database.Esqueleto.PostgreSQL.
ilike :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s) -> SqlExpr (Value Bool)
infixr 2 `ilike`

-- | 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 `<a>like</a>` (%) ++. val "John" ++. (%)
--   
(%) :: SqlString s => SqlExpr (Value s)

-- | The CONCAT function with a variable number of parameters.
--   Supported by MySQL and PostgreSQL. SQLite supports this in versions
--   after 3.44.0, and persistent-sqlite supports this in versions
--   2.13.3.0 and after.
concat_ :: SqlString s => [SqlExpr (Value s)] -> SqlExpr (Value s)

-- | The || string concatenation operator (named after Haskell's
--   ++ in order to avoid naming clash with ||.).
--   
--   Supported by SQLite and PostgreSQL.
--   
--   MySQL support requires setting the SQL mode to
--   PIPES_AS_CONCAT or ANSI - see this StackOverflow
--   answer.
(++.) :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s) -> SqlExpr (Value s)
infixr 5 ++.

-- | 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.
castString :: (SqlString s, SqlString r) => SqlExpr (Value s) -> SqlExpr (Value r)

-- | Execute a subquery SELECT in an SqlExpression. Returns a list
--   of values.
subList_select :: PersistField a => SqlQuery (SqlExpr (Value a)) -> SqlExpr (ValueList a)

-- | Lift a list of constant value from Haskell-land to the query.
valList :: PersistField typ => [typ] -> SqlExpr (ValueList 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.
justList :: SqlExpr (ValueList typ) -> SqlExpr (ValueList (Maybe typ))

-- | 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 `<tt>in_</tt>` valList personIds
--   return person
--   
--   
--   Where personIds is of type [Key Person].
in_ :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (ValueList typ) -> SqlExpr (Value Bool)

-- | NOT IN operator.
notIn :: PersistField typ => SqlExpr (Value typ) -> SqlExpr (ValueList typ) -> SqlExpr (Value Bool)

-- | EXISTS operator. For example:
--   
--   
--   select $
--   from $ \person -> do
--   where_ $ exists $
--            from $ \post -> do
--            where_ (post ^. BlogPostAuthorId ==. person ^. PersonId)
--   return person
--   
exists :: SqlQuery () -> SqlExpr (Value Bool)

-- | NOT EXISTS operator.
notExists :: SqlQuery () -> SqlExpr (Value Bool)

-- | 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.
set :: PersistEntity val => SqlExpr (Entity val) -> [SqlExpr (Entity val) -> SqlExpr Update] -> SqlQuery ()
(=.) :: (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 statement. For example:
--   
--   
--   select $
--   return $
--   case_
--      [ when_
--          (exists $
--          from $ \p -> do
--          where_ (p ^. PersonName ==. val "Mike"))
--        then_
--          (subSelect $
--          from $ \v -> do
--          let sub =
--                  from $ \c -> do
--                  where_ (c ^. PersonName ==. val "Mike")
--                  return (c ^. PersonFavNum)
--          where_ (just (v ^. PersonFavNum) >. subSelect 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.
--   
case_ :: PersistField a => [(SqlExpr (Value Bool), SqlExpr (Value a))] -> SqlExpr (Value a) -> SqlExpr (Value a)

-- | 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 `<tt>InnerJoin</tt>` 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.
toBaseId :: ToBaseId ent => SqlExpr (Value (Key ent)) -> SqlExpr (Value (Key (BaseEnt ent)))

-- | The inverse of toBaseId. Note that this is somewhat less "safe"
--   than toBaseId. Calling toBaseId will usually mean that a
--   foreign key constraint is present that guarantees the presence of the
--   base ID. fromBaseId has no such guarantee. Consider the code
--   example given in toBaseId:
--   
--   
--   Bar
--     barNum Int
--   Foo
--     bar BarId
--     fooNum Int
--     Primary bar
--   
--   
--   
--   instance ToBaseId Foo where
--     type BaseEnt Foo = Bar
--     toBaseIdWitness barId = FooKey barId
--   
--   
--   The type of toBaseId for Foo would be:
--   
--   
--   toBaseId :: SqlExpr (Value FooId) -> SqlExpr (Value BarId)
--   
--   
--   The foreign key constraint on Foo means that every
--   FooId points to a BarId in the database. However,
--   fromBaseId will not have this:
--   
--   
--   fromBaseId :: SqlExpr (Value BarId) -> SqlExpr (Value FooId)
--   
fromBaseId :: ToBaseId ent => SqlExpr (Value (Key (BaseEnt ent))) -> SqlExpr (Value (Key ent))

-- | Like toBaseId, but works on Maybe keys.
toBaseIdMaybe :: ToBaseId ent => SqlExpr (Value (Maybe (Key ent))) -> SqlExpr (Value (Maybe (Key (BaseEnt ent))))

-- | As fromBaseId, but works on Maybe keys.
fromBaseIdMaybe :: ToBaseId ent => SqlExpr (Value (Maybe (Key (BaseEnt ent)))) -> SqlExpr (Value (Maybe (Key ent)))

-- | 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.
subSelect :: (PersistField a, NullableFieldProjection a a') => SqlQuery (SqlExpr (Value 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).
subSelectMaybe :: PersistField a => SqlQuery (SqlExpr (Value (Maybe a))) -> SqlExpr (Value (Maybe 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.
subSelectCount :: (Num a, PersistField a) => SqlQuery ignored -> 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)
--   
subSelectForeign :: (BackendCompatible SqlBackend (PersistEntityBackend val1), PersistEntity val1, PersistEntity val2, PersistField a) => SqlExpr (Entity val2) -> EntityField val2 (Key val1) -> (SqlExpr (Entity val1) -> SqlExpr (Value a)) -> SqlExpr (Value 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.
subSelectList :: PersistField a => SqlQuery (SqlExpr (Value a)) -> SqlExpr (ValueList a)

-- | Execute a subquery SELECT in a SqlExpr. This function
--   is unsafe, because it can throw runtime exceptions in two cases:
--   
--   
--   
- 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.
--   
- 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.
subSelectUnsafe :: PersistField a => SqlQuery (SqlExpr (Value a)) -> SqlExpr (Value a)

-- | Class that enables one to use toBaseId to convert an entity's
--   key on a query into another (cf. toBaseId).
class ToBaseId ent where {
    
    -- | e.g. <tt>type BaseEnt MyBase = MyChild</tt>
    type BaseEnt 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.
toBaseIdWitness :: ToBaseId ent => Key (BaseEnt ent) -> Key ent

-- | Syntax sugar for case_.
when_ :: expr (Value Bool) -> () -> expr a -> (expr (Value Bool), expr a)

-- | Syntax sugar for case_.
then_ :: ()

-- | Syntax sugar for case_.
else_ :: expr a -> expr a

-- | 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 `<a>LeftOuterJoin</a>` mb) -> ...
--   from $ \(p1 `<a>InnerJoin</a>` f `<a>InnerJoin</a>` p2) -> ...
--   from $ \((p1 `<a>InnerJoin</a>` f) `<a>InnerJoin</a>` 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 `<a>LeftOuterJoin</a>` mb)
--     :: (...) => InnerJoin (expr (Entity Person)) (expr (Maybe (Entity BlogPost)))
--   (p1 `<a>InnerJoin</a>` f `<a>InnerJoin</a>` p2)
--     :: (...) => InnerJoin
--                   (InnerJoin (expr (Entity Person))
--                              (expr (Entity Follow)))
--                   (expr (Entity Person))
--   (p1 `<a>InnerJoin</a>` (f `<a>InnerJoin</a>` p2)) ::
--     :: (...) => InnerJoin
--                   (expr (Entity Person))
--                   (InnerJoin (expr (Entity Follow))
--                              (expr (Entity Person)))
--   
--   
--   Note that some backends may not support all kinds of JOINs.
from :: From a => (a -> SqlQuery b) -> SqlQuery b

-- | A single value (as opposed to a whole entity). You may use
--   (^.) or (?.) to get a Value
--   from an Entity.
newtype Value a
Value :: a -> Value a
[unValue] :: Value a -> 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).
newtype ValueList a
ValueList :: a -> ValueList a

-- | Phantom type used by orderBy, asc and desc.
data OrderBy

-- | Phantom type used by distinctOn and don.
data DistinctOn

-- | 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.
data LockingKind

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

-- | Deprecated: The constructors for LockingKind are deprecated
--   in v3.6.0.0. Instead, please refer to the smart constructors
--   forUpdate and forUpdateSkipLocked.
ForUpdate :: LockingKind

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

-- | Deprecated: The constructors for LockingKind are deprecated
--   in v3.6.0.0. Instead, please refer to the smart constructors
--   forUpdate and forUpdateSkipLocked.
ForUpdateSkipLocked :: LockingKind

-- | FOR SHARE syntax. Supported by PostgreSQL.

-- | Deprecated: The constructors for LockingKind are deprecated
--   in v3.6.0.0. Instead, please refer to the smart constructor
--   forShare exported from Database.Esqueleto.PostgreSQL.
ForShare :: LockingKind

-- | LOCK IN SHARE MODE syntax. Supported by MySQL.

-- | Deprecated: The constructors for LockingKind are deprecated
--   in v3.6.0.0. Instead, please refer to the smart constructors
--   lockInShareMode exported from Database.Esqueleto.MySQL.
LockInShareMode :: LockingKind

-- | FOR UPDATE syntax.
--   
--   Usage:
--   
--   
--   locking forUpdate
--   
forUpdate :: LockingKind

-- | FOR UPDATE SKIP LOCKED syntax.
--   
--   
--   locking forUpdateSkipLocked
--   
forUpdateSkipLocked :: LockingKind

-- | 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
--   
class LockableEntity a
flattenLockableEntity :: LockableEntity a => a -> NonEmpty LockableSqlExpr

-- | 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.
class PersistField a => SqlString a

-- | Data type that represents an INNER JOIN (see
--   LeftOuterJoin for an example).
data InnerJoin a b
InnerJoin :: a -> b -> InnerJoin a b
infixl 2 `InnerJoin`
infixl 2 `InnerJoin`

-- | Data type that represents a CROSS JOIN (see
--   LeftOuterJoin for an example).
data CrossJoin a b
CrossJoin :: a -> b -> CrossJoin a b
infixl 2 `CrossJoin`
infixl 2 `CrossJoin`

-- | Data type that represents a LEFT OUTER JOIN. For example,
--   
--   
--   select $
--   from $ \(person `<tt>LeftOuterJoin</tt>` pet) ->
--     ...
--   
--   
--   is translated into
--   
--   
--   SELECT ...
--   FROM Person LEFT OUTER JOIN Pet
--   ...
--   
--   
--   See also: from.
data LeftOuterJoin a b
LeftOuterJoin :: a -> b -> LeftOuterJoin a b
infixl 2 `LeftOuterJoin`
infixl 2 `LeftOuterJoin`

-- | Data type that represents a RIGHT OUTER JOIN (see
--   LeftOuterJoin for an example).
data RightOuterJoin a b
RightOuterJoin :: a -> b -> RightOuterJoin a b
infixl 2 `RightOuterJoin`
infixl 2 `RightOuterJoin`

-- | Data type that represents a FULL OUTER JOIN (see
--   LeftOuterJoin for an example).
data FullOuterJoin a b
FullOuterJoin :: a -> b -> FullOuterJoin a b
infixl 2 `FullOuterJoin`
infixl 2 `FullOuterJoin`

-- | (Internal) A kind of JOIN.
data JoinKind

-- | 
--   INNER JOIN
--   
InnerJoinKind :: JoinKind

-- | 
--   CROSS JOIN
--   
CrossJoinKind :: JoinKind

-- | 
--   LEFT OUTER JOIN
--   
LeftOuterJoinKind :: JoinKind

-- | 
--   RIGHT OUTER JOIN
--   
RightOuterJoinKind :: JoinKind

-- | 
--   FULL OUTER JOIN
--   
FullOuterJoinKind :: JoinKind

-- | Exception thrown whenever on is used to create an ON
--   clause but no matching JOIN is found.
data OnClauseWithoutMatchingJoinException
OnClauseWithoutMatchingJoinException :: String -> OnClauseWithoutMatchingJoinException

-- | SQL backend for esqueleto using SqlPersistT.
data SqlQuery 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.
data SqlExpr a

-- | Constraint synonym for persistent entities whose backend is
--   SqlBackend.
type SqlEntity ent = (PersistEntity ent, PersistEntityBackend ent ~ SqlBackend)

-- | 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).
select :: forall a r (m :: Type -> Type) backend. (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 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
--   
selectOne :: forall a r (m :: Type -> Type) backend. (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 a
--   Source of rows.
selectSource :: forall a r backend (m :: Type -> Type). (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 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)
--   
delete :: forall (m :: Type -> Type) backend. (MonadIO m, SqlBackendCanWrite backend) => SqlQuery () -> ReaderT backend m ()

-- | Same as delete, but returns the number of rows affected.
deleteCount :: forall (m :: Type -> Type) backend. (MonadIO m, SqlBackendCanWrite backend) => SqlQuery () -> ReaderT backend m Int64

-- | 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)
--   
update :: forall (m :: Type -> Type) val backend. (MonadIO m, PersistEntity val, BackendCompatible SqlBackend (PersistEntityBackend val), SqlBackendCanWrite backend) => (SqlExpr (Entity val) -> SqlQuery ()) -> ReaderT backend m ()

-- | Same as update, but returns the number of rows affected.
updateCount :: forall (m :: Type -> Type) val backend. (MonadIO m, PersistEntity val, BackendCompatible SqlBackend (PersistEntityBackend val), SqlBackendCanWrite backend) => (SqlExpr (Entity val) -> SqlQuery ()) -> ReaderT backend m Int64

-- | Insert a PersistField for every selected value.
insertSelect :: forall (m :: Type -> Type) a backend. (MonadIO m, PersistEntity a, SqlBackendCanWrite backend) => SqlQuery (SqlExpr (Insertion a)) -> ReaderT backend m ()

-- | Insert a PersistField for every selected value, return the
--   count afterward
insertSelectCount :: forall (m :: Type -> Type) a backend. (MonadIO m, PersistEntity a, SqlBackendCanWrite backend) => SqlQuery (SqlExpr (Insertion a)) -> ReaderT backend m Int64

-- | Apply a PersistField constructor to SqlExpr Value
--   arguments.
(<#) :: (a -> b) -> SqlExpr (Value a) -> SqlExpr (Insertion b)

-- | Apply extra SqlExpr Value arguments to a PersistField
--   constructor
(<&>) :: SqlExpr (Insertion (a -> b)) -> SqlExpr (Value a) -> SqlExpr (Insertion b)

-- | 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.
renderQueryToText :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => Mode -> SqlQuery a -> 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.
renderQuerySelect :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => SqlQuery a -> 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.
renderQueryUpdate :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => SqlQuery a -> 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.
renderQueryDelete :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => SqlQuery a -> 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.
renderQueryInsertInto :: forall a r backend (m :: Type -> Type). (SqlSelect a r, BackendCompatible SqlBackend backend, Monad m) => SqlQuery a -> ReaderT backend m (Text, [PersistValue])

-- | (Internal) Class that implements the tuple from magic (see
--   fromStart).
class From a

-- | valkey i = val . toSqlKey
--   (https://github.com/prowdsponsor/esqueleto/issues/9).
valkey :: (ToBackendKey SqlBackend entity, PersistField (Key entity)) => Int64 -> 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).
valJ :: PersistField (Key entity) => Value (Key entity) -> SqlExpr (Value (Key entity))

-- | 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.
associateJoin :: forall e1 e0. Ord (Key e0) => [(Entity e0, e1)] -> Map (Key e0) (e0, [e1])

-- | Synonym for delete that does not clash with
--   esqueleto's delete.
deleteKey :: forall backend val (m :: Type -> Type). (PersistStore backend, BaseBackend backend ~ PersistEntityBackend val, MonadIO m, PersistEntity val) => Key val -> ReaderT backend m ()

-- | 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.
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 allows multiple different backends (databases).
    type PersistEntityBackend record;
    
    -- | By default, a backend will automatically generate the key Instead you
    --   can specify a Primary key made up of unique values.
    data Key record;
    
    -- | An <a>EntityField</a> is parameterised by the Haskell record it
    --   belongs to and the additional type of that field.
    --   
    --   As of <tt>persistent-2.11.0.0</tt>, it's possible to use the
    --   <tt>OverloadedLabels</tt> language extension to refer to
    --   <a>EntityField</a> values polymorphically. See the documentation on
    --   <a>SymbolToField</a> for more information.
    data EntityField record :: Type -> Type;
    
    -- | Unique keys besides the <a>Key</a>.
    data Unique record;
}

-- | A lower-level key operation.
keyToValues :: PersistEntity record => Key record -> [PersistValue]

-- | A lower-level key operation.
keyFromValues :: PersistEntity record => [PersistValue] -> Either Text (Key record)

-- | A meta-operation to retrieve the Key EntityField.
persistIdField :: PersistEntity record => EntityField record (Key record)

-- | Retrieve the EntityDef meta-data for the record.
entityDef :: PersistEntity record => proxy record -> EntityDef

-- | Return meta-data for a given EntityField.
persistFieldDef :: PersistEntity record => EntityField record typ -> FieldDef

-- | A meta-operation to get the database fields of a record.
toPersistFields :: PersistEntity record => record -> [PersistValue]

-- | A lower-level operation to convert from database values to a Haskell
--   record.
fromPersistValues :: PersistEntity record => [PersistValue] -> Either Text 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
--   
tabulateEntityA :: (PersistEntity record, Applicative f) => (forall a. () => EntityField record a -> f a) -> f (Entity record)

-- | Like tabulateEntityA, but works with any Apply f. This
--   works because all entities have at least one field, and so we can
--   tabulate things into semigroup-like shapes instead.
tabulateEntityApply :: (PersistEntity record, Apply f) => (forall a. () => EntityField record a -> f a) -> f (Entity record)

-- | A meta operation to retrieve all the Unique keys.
persistUniqueKeys :: PersistEntity record => record -> [Unique record]

-- | A lower level operation.
persistUniqueToFieldNames :: PersistEntity record => Unique record -> NonEmpty (FieldNameHS, FieldNameDB)

-- | A lower level operation.
persistUniqueToValues :: PersistEntity record => Unique record -> [PersistValue]

-- | Use a PersistField as a lens.
fieldLens :: PersistEntity record => EntityField record field -> forall (f :: Type -> Type). Functor f => (field -> f field) -> Entity record -> f (Entity 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.
keyFromRecordM :: PersistEntity record => Maybe (record -> Key record)

-- | By default, a backend will automatically generate the key Instead you
--   can specify a Primary key made up of unique values.
data family Key record
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

-- | 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). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Key record)

-- | 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   |
--   +-----+------+-----+
--   
insert_ :: forall record (m :: Type -> Type). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m ()

-- | 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). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => [record] -> ReaderT backend m [Key record]

-- | 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   |
--   +-----+------+-----+
--   
insertMany_ :: forall record (m :: Type -> Type). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => [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   |
--   +-----+------+-----+
--   
insertEntityMany :: forall record (m :: Type -> Type). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend) => [Entity 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   |
--   +-----+------+-----+
--   
insertKey :: forall record (m :: Type -> Type). (PersistStoreWrite backend, 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  |
--   +-----+------+-----+
--   
repsert :: forall record (m :: Type -> Type). (PersistStoreWrite backend, 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      |
--   +-----+----------------+---------+
--   
repsertMany :: forall record (m :: Type -> Type). (PersistStoreWrite backend, 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   |
--   +-----+------+-----+
--   
replace :: forall record (m :: Type -> Type). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend) => Key record -> record -> ReaderT backend m ()

-- | 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   |
--   +-----+------+-----+
--   
updateGet :: forall record (m :: Type -> Type). (PersistStoreWrite backend, MonadIO m, PersistRecordBackend record backend) => Key record -> [Update record] -> ReaderT backend m record
data PersistFilter
Eq :: PersistFilter
Ne :: PersistFilter
Gt :: PersistFilter
Lt :: PersistFilter
Ge :: PersistFilter
Le :: PersistFilter
In :: PersistFilter
NotIn :: PersistFilter
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

-- | 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 |
--   +------+-----+
--   
get :: forall record (m :: Type -> Type). (PersistStoreRead backend, MonadIO m, PersistRecordBackend record backend) => Key record -> ReaderT backend m (Maybe 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 |
--   +----+-------+-----+
--   
getMany :: forall record (m :: Type -> Type). (PersistStoreRead backend, MonadIO m, PersistRecordBackend record backend) => [Key record] -> ReaderT backend m (Map (Key record) record)

-- | 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.
--   
class (PersistUniqueRead backend, PersistStoreWrite backend) => PersistUniqueWrite backend

-- | 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   |
--   +-----+------+-----+
--   
deleteBy :: forall record (m :: Type -> Type). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m ()

-- | 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). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Maybe (Key record))

-- | 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.
insertUnique_ :: forall record (m :: Type -> Type). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Maybe ())

-- | 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.
upsert :: forall record (m :: Type -> Type). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend, OnlyOneUniqueKey record, SafeToInsert record) => record -> [Update record] -> ReaderT backend m (Entity record)

-- | 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  |
--   +-----+-----+-----+
--   
upsertBy :: forall record (m :: Type -> Type). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => Unique record -> record -> [Update record] -> ReaderT backend m (Entity record)

-- | Put many records into db
--   
--   
--   
- insert new records that do not exist (or violate any unique
--   constraints)
--   
- replace existing records (matching any unique constraint)
--   
putMany :: forall record (m :: Type -> Type). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => [record] -> ReaderT backend m ()

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

-- | 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.
migrate :: [EntityDef] -> EntityDef -> Migration

-- | Report a single error in a Migration.
reportError :: Text -> Migration

-- | Unique keys besides the Key.
data family Unique record

-- | A single column (see rawSql). Any PersistField may
--   be used here, including PersistValue (which does not do any
--   processing).
newtype Single a
Single :: a -> Single a
[unSingle] :: Single a -> a
data Column
Column :: !FieldNameDB -> !Bool -> !SqlType -> !Maybe Text -> !Maybe Text -> !Maybe ConstraintNameDB -> !Maybe Integer -> !Maybe ColumnReference -> Column
[cName] :: Column -> !FieldNameDB
[cNull] :: Column -> !Bool
[cSqlType] :: Column -> !SqlType
[cDefault] :: Column -> !Maybe Text
[cGenerated] :: Column -> !Maybe Text
[cDefaultConstraintName] :: Column -> !Maybe ConstraintNameDB
[cMaxLen] :: Column -> !Maybe Integer
[cReference] :: Column -> !Maybe ColumnReference

-- | 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)
--   
rawSql :: forall a (m :: Type -> Type) backend. (RawSql a, MonadIO m, BackendCompatible SqlBackend backend) => Text -> [PersistValue] -> ReaderT backend m [a]

-- | 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.
class PersistConfig c where {
    type PersistConfigBackend c :: Type -> Type -> Type -> Type;
    type PersistConfigPool c;
}

-- | Load the config settings from a Value, most likely taken from a
--   YAML config file.
loadConfig :: PersistConfig c => Value -> Parser c

-- | Modify the config settings based on environment variables.
applyEnv :: PersistConfig c => c -> IO c

-- | Create a new connection pool based on the given config settings.
createPoolConfig :: PersistConfig c => c -> IO (PersistConfigPool c)

-- | Run a database action by taking a connection from the pool.
runPool :: (PersistConfig c, MonadUnliftIO m) => c -> PersistConfigBackend c m a -> PersistConfigPool c -> m a
type family PersistConfigBackend c :: Type -> Type -> Type -> Type
type family PersistConfigPool c

-- | An ConstraintNameHS represents the Haskell-side name that
--   persistent will use for a constraint.
newtype ConstraintNameHS
ConstraintNameHS :: Text -> ConstraintNameHS
[unConstraintNameHS] :: ConstraintNameHS -> Text

-- | A ConstraintNameDB represents the datastore-side name that
--   persistent will use for a constraint.
newtype ConstraintNameDB
ConstraintNameDB :: Text -> ConstraintNameDB
[unConstraintNameDB] :: ConstraintNameDB -> Text

-- | An EntityNameDB represents the datastore-side name that
--   persistent will use for an entity.
newtype EntityNameDB
EntityNameDB :: Text -> EntityNameDB
[unEntityNameDB] :: EntityNameDB -> Text

-- | An EntityNameHS represents the Haskell-side name that
--   persistent will use for an entity.
newtype EntityNameHS
EntityNameHS :: Text -> EntityNameHS
[unEntityNameHS] :: EntityNameHS -> Text

-- | A FieldNameHS represents the Haskell-side name that
--   persistent will use for a field.
newtype FieldNameHS
FieldNameHS :: Text -> FieldNameHS
[unFieldNameHS] :: FieldNameHS -> Text

-- | A FieldNameDB represents the datastore-side name that
--   persistent will use for a field.
newtype FieldNameDB
FieldNameDB :: Text -> FieldNameDB
[unFieldNameDB] :: FieldNameDB -> Text

-- | Convenience operations for working with '-NameDB' types.
class DatabaseName a
escapeWith :: DatabaseName a => (Text -> str) -> a -> str

-- | A type that determines how a backend should handle the literal.
data LiteralType

-- | The accompanying value will be escaped before inserting into the
--   database. This is the correct default choice to use.
Escaped :: LiteralType

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

-- | 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.
DbSpecific :: LiteralType

-- | A raw value which can be stored in any backend and can be marshalled
--   to and from a PersistField.
data PersistValue
PersistText :: Text -> PersistValue
PersistByteString :: ByteString -> PersistValue
PersistInt64 :: Int64 -> PersistValue
PersistDouble :: Double -> PersistValue
PersistRational :: Rational -> PersistValue
PersistBool :: Bool -> PersistValue
PersistDay :: Day -> PersistValue
PersistTimeOfDay :: TimeOfDay -> PersistValue
PersistUTCTime :: UTCTime -> PersistValue
PersistNull :: PersistValue
PersistList :: [PersistValue] -> PersistValue
PersistMap :: [(Text, PersistValue)] -> PersistValue

-- | Intended especially for MongoDB backend
PersistObjectId :: ByteString -> PersistValue

-- | Intended especially for PostgreSQL backend for text arrays
PersistArray :: [PersistValue] -> PersistValue

-- | 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.
PersistLiteral_ :: LiteralType -> 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.
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.
pattern PersistLiteralEscaped :: 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.
pattern PersistDbSpecific :: ByteString -> PersistValue
fromPersistValueText :: PersistValue -> Either Text Text

-- | Please refer to the documentation for the database in question for a
--   full overview of the semantics of the varying isolation levels
data IsolationLevel
ReadUncommitted :: IsolationLevel
ReadCommitted :: IsolationLevel
RepeatableRead :: IsolationLevel
Serializable :: IsolationLevel

-- | 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.
data FieldDef
FieldDef :: !FieldNameHS -> !FieldNameDB -> !FieldType -> !SqlType -> ![FieldAttr] -> !Bool -> !ReferenceDef -> !FieldCascade -> !Maybe Text -> !Maybe Text -> !Bool -> FieldDef

-- | 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.
[fieldHaskell] :: FieldDef -> !FieldNameHS

-- | The name of the field in the database. For SQL databases, this
--   corresponds to the column name.
[fieldDB] :: FieldDef -> !FieldNameDB

-- | The type of the field in Haskell.
[fieldType] :: FieldDef -> !FieldType

-- | The type of the field in a SQL database.
[fieldSqlType] :: FieldDef -> !SqlType

-- | User annotations for a field. These are provided with the !
--   operator.
[fieldAttrs] :: FieldDef -> ![FieldAttr]

-- | If this is True, then the Haskell datatype will have a strict
--   record field. The default value for this is True.
[fieldStrict] :: FieldDef -> !Bool
[fieldReference] :: FieldDef -> !ReferenceDef

-- | 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.
[fieldCascade] :: FieldDef -> !FieldCascade

-- | Optional comments for a Field.
[fieldComments] :: FieldDef -> !Maybe Text

-- | Whether or not the field is a GENERATED column, and
--   additionally the expression to use for generation.
[fieldGenerated] :: FieldDef -> !Maybe Text

-- | True if the field is an implicit ID column. False
--   otherwise.
[fieldIsImplicitIdColumn] :: FieldDef -> !Bool
data PersistUpdate
Assign :: PersistUpdate
Add :: PersistUpdate
Subtract :: PersistUpdate
Multiply :: PersistUpdate
Divide :: PersistUpdate
BackendSpecificUpdate :: Text -> PersistUpdate
type family BackendSpecificUpdate backend record
data UpdateException
KeyNotFound :: String -> UpdateException
UpsertError :: String -> UpdateException

-- | 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.
data SqlType
SqlString :: SqlType
SqlInt32 :: SqlType
SqlInt64 :: SqlType
SqlReal :: SqlType
SqlNumeric :: Word32 -> Word32 -> SqlType
SqlBool :: SqlType
SqlDay :: SqlType
SqlTime :: SqlType

-- | Always uses UTC timezone
SqlDayTime :: SqlType
SqlBlob :: SqlType

-- | a backend-specific name
SqlOther :: Text -> SqlType
data PersistException

-- | Generic Exception
PersistError :: Text -> PersistException
PersistMarshalError :: Text -> PersistException
PersistInvalidField :: Text -> PersistException
PersistForeignConstraintUnmet :: Text -> PersistException
PersistMongoDBError :: Text -> PersistException
PersistMongoDBUnsupported :: Text -> PersistException

-- | An action that might happen on a deletion or update on a foreign key
--   change.
data CascadeAction
Cascade :: CascadeAction
Restrict :: CascadeAction
SetNull :: CascadeAction
SetDefault :: CascadeAction

-- | 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.
data FieldCascade
FieldCascade :: !Maybe CascadeAction -> !Maybe CascadeAction -> FieldCascade
[fcOnUpdate] :: FieldCascade -> !Maybe CascadeAction
[fcOnDelete] :: FieldCascade -> !Maybe CascadeAction
data ForeignDef
ForeignDef :: !EntityNameHS -> !EntityNameDB -> !ConstraintNameHS -> !ConstraintNameDB -> !FieldCascade -> ![(ForeignFieldDef, ForeignFieldDef)] -> ![Attr] -> Bool -> Bool -> ForeignDef
[foreignRefTableHaskell] :: ForeignDef -> !EntityNameHS
[foreignRefTableDBName] :: ForeignDef -> !EntityNameDB
[foreignConstraintNameHaskell] :: ForeignDef -> !ConstraintNameHS
[foreignConstraintNameDBName] :: ForeignDef -> !ConstraintNameDB

-- | Determine how the field will cascade on updates and deletions.
[foreignFieldCascade] :: ForeignDef -> !FieldCascade
[foreignFields] :: ForeignDef -> ![(ForeignFieldDef, ForeignFieldDef)]
[foreignAttrs] :: ForeignDef -> ![Attr]
[foreignNullable] :: ForeignDef -> Bool

-- | Determines if the reference is towards a Primary Key or not.
[foreignToPrimary] :: ForeignDef -> Bool

-- | Used instead of FieldDef to generate a smaller amount of code
type ForeignFieldDef = (FieldNameHS, FieldNameDB)
data CompositeDef
CompositeDef :: !NonEmpty FieldDef -> ![Attr] -> CompositeDef
[compositeFields] :: CompositeDef -> !NonEmpty FieldDef
[compositeAttrs] :: CompositeDef -> ![Attr]

-- | 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 = []
--       }
--   
data UniqueDef
UniqueDef :: !ConstraintNameHS -> !ConstraintNameDB -> !NonEmpty (FieldNameHS, FieldNameDB) -> ![Attr] -> UniqueDef
[uniqueHaskell] :: UniqueDef -> !ConstraintNameHS
[uniqueDBName] :: UniqueDef -> !ConstraintNameDB
[uniqueFields] :: UniqueDef -> !NonEmpty (FieldNameHS, FieldNameDB)
[uniqueAttrs] :: UniqueDef -> ![Attr]

-- | An EmbedFieldDef is the same as a FieldDef But it is only used for
--   embeddedFields so it only has data needed for embedding
data EmbedFieldDef
EmbedFieldDef :: FieldNameDB -> Maybe (Either SelfEmbed EntityNameHS) -> EmbedFieldDef
[emFieldDB] :: EmbedFieldDef -> FieldNameDB
[emFieldEmbed] :: EmbedFieldDef -> Maybe (Either SelfEmbed EntityNameHS)

-- | An EmbedEntityDef is the same as an EntityDef But it is only used for
--   fieldReference so it only has data needed for embedding
data EmbedEntityDef
EmbedEntityDef :: EntityNameHS -> [EmbedFieldDef] -> EmbedEntityDef
[embeddedHaskell] :: EmbedEntityDef -> EntityNameHS
[embeddedFields] :: EmbedEntityDef -> [EmbedFieldDef]

-- | There are 3 kinds of references 1) composite (to fields that exist in
--   the record) 2) single field 3) embedded
data ReferenceDef
NoReference :: ReferenceDef

-- | 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
ForeignRef :: !EntityNameHS -> ReferenceDef
EmbedRef :: EntityNameHS -> ReferenceDef

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

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

-- | Optional module and name.
FTTypeCon :: Maybe Text -> Text -> FieldType
FTLit :: FieldTypeLit -> FieldType
FTTypePromoted :: Text -> FieldType
FTApp :: FieldType -> FieldType -> FieldType
FTList :: FieldType -> FieldType

-- | 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.
data FieldAttr

-- | 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
--   
FieldAttrMaybe :: FieldAttr

-- | 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
--   
FieldAttrNullable :: FieldAttr

-- | 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
--   
FieldAttrMigrationOnly :: FieldAttr

-- | 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
--   
FieldAttrSafeToRemove :: FieldAttr

-- | 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
--   
FieldAttrNoreference :: FieldAttr

-- | 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.
FieldAttrReference :: Text -> FieldAttr

-- | 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"
--   
FieldAttrConstraint :: Text -> FieldAttr

-- | 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.
FieldAttrDefault :: Text -> FieldAttr

-- | 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
--   
FieldAttrSqltype :: Text -> FieldAttr

-- | Set a maximum length for a column. Useful for VARCHAR and indexes.
--   
--   
--   User
--       name     Text    maxlen=200
--   
--       UniqueName name
--   
FieldAttrMaxlen :: Integer -> FieldAttr

-- | 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.
FieldAttrSql :: Text -> FieldAttr

-- | A grab bag of random attributes that were unrecognized by the parser.
FieldAttrOther :: Text -> FieldAttr
type Attr = Text
type ExtraLine = [Text]

-- | The definition for the entity's primary key ID.
data EntityIdDef

-- | The entity has a single key column, and it is a surrogate key - that
--   is, you can't go from rec -> Key rec.
EntityIdField :: !FieldDef -> EntityIdDef

-- | 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.
EntityIdNaturalKey :: !CompositeDef -> EntityIdDef

-- | 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.
data EntityDef

-- | 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.
data WhyNullable
ByMaybeAttr :: WhyNullable
ByNullableAttr :: WhyNullable
data IsNullable
Nullable :: !WhyNullable -> IsNullable
NotNullable :: IsNullable

-- | 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.
data Checkmark

-- | When used on a uniqueness constraint, there may be at most one
--   Active record.
Active :: Checkmark

-- | When used on a uniqueness constraint, there may be any number of
--   Inactive records.
Inactive :: Checkmark
fieldAttrsContainsNullable :: [FieldAttr] -> IsNullable

-- | Return the [FieldDef] for the entity keys.
entitiesPrimary :: EntityDef -> NonEmpty FieldDef
entityPrimary :: EntityDef -> Maybe CompositeDef

-- | Returns a NonEmpty list of FieldDef that correspond with
--   the key columns for an EntityDef.
keyAndEntityFields :: EntityDef -> NonEmpty FieldDef

-- | Returns a NonEmpty list of FieldDef that correspond with
--   the key columns for an 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 fields on the Haskell type use keyAndEntityFieldsDatabase
keyAndEntityFieldsDatabase :: EntityDef -> NonEmpty FieldDef

-- | Parse raw field attributes into structured form. Any unrecognized
--   attributes will be preserved, identically as they are encountered, as
--   FieldAttrOther values.
parseFieldAttrs :: [Text] -> [FieldAttr]
isFieldNotGenerated :: FieldDef -> Bool

-- | Returns True if the FieldDef does not have a
--   MigrationOnly or SafeToRemove flag from the
--   QuasiQuoter.
isHaskellField :: FieldDef -> Bool

-- | A FieldCascade that does nothing.
noCascade :: FieldCascade

-- | Renders a FieldCascade value such that it can be used in SQL
--   migrations.
renderFieldCascade :: FieldCascade -> Text

-- | Render a CascadeAction to Text such that it can be used
--   in a SQL command.
renderCascadeAction :: CascadeAction -> Text

-- | A Statement is a representation of a database query that has
--   been prepared and stored on the server side.
data Statement
Statement :: IO () -> IO () -> ([PersistValue] -> IO Int64) -> (forall (m :: Type -> Type). MonadIO m => [PersistValue] -> Acquire (ConduitM () [PersistValue] m ())) -> Statement
[stmtFinalize] :: Statement -> IO ()
[stmtReset] :: Statement -> IO ()
[stmtExecute] :: Statement -> [PersistValue] -> IO Int64
[stmtQuery] :: Statement -> forall (m :: Type -> Type). MonadIO m => [PersistValue] -> Acquire (ConduitM () [PersistValue] m ())
data InsertSqlResult
ISRSingle :: Text -> InsertSqlResult
ISRInsertGet :: Text -> Text -> InsertSqlResult
ISRManyKeys :: Text -> [PersistValue] -> InsertSqlResult
type LogFunc = Loc -> LogSource -> LogLevel -> LogStr -> IO ()

-- | Replace the FieldDef FieldAttr with the new list.
setFieldAttrs :: [FieldAttr] -> FieldDef -> FieldDef

-- | Modify the list of field attributes.
overFieldAttrs :: ([FieldAttr] -> [FieldAttr]) -> FieldDef -> FieldDef

-- | Add an attribute to the list of field attributes.
addFieldAttr :: FieldAttr -> FieldDef -> FieldDef

-- | Check if the field definition is nullable
isFieldNullable :: FieldDef -> IsNullable

-- | Check if the field is `Maybe a`
isFieldMaybe :: FieldDef -> Bool

-- | 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.
getEntityUniquesNoPrimaryKey :: 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.
getEntityUniques :: EntityDef -> [UniqueDef]

-- | Retrieve the Haskell name of the given entity.
getEntityHaskellName :: EntityDef -> EntityNameHS

-- | Return the database name for the given entity.
getEntityDBName :: EntityDef -> EntityNameDB
getEntityExtra :: EntityDef -> Map Text [[Text]]

setEntityDBName :: EntityNameDB -> EntityDef -> EntityDef
getEntityComments :: EntityDef -> Maybe Text

getEntityForeignDefs :: EntityDef -> [ForeignDef]

-- | 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.
getEntityFields :: 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.
getEntityFieldsDatabase :: EntityDef -> [FieldDef]

isEntitySum :: EntityDef -> Bool

getEntityId :: EntityDef -> EntityIdDef

getEntityIdField :: EntityDef -> Maybe FieldDef

-- | Set an entityId to be the given FieldDef.
setEntityId :: FieldDef -> EntityDef -> EntityDef

setEntityIdDef :: EntityIdDef -> EntityDef -> EntityDef

getEntityKeyFields :: EntityDef -> NonEmpty FieldDef

-- | Perform a mapping function over all of the entity fields, as
--   determined by getEntityFieldsDatabase.
overEntityFields :: ([FieldDef] -> [FieldDef]) -> EntityDef -> EntityDef

-- | Gets the Source of the definition of the entity.
--   
--   Note that as of this writing the span covers the entire file or
--   quasiquote where the item is defined due to parsing limitations. This
--   may be changed in a future release to be more accurate.
getEntitySpan :: EntityDef -> Maybe SourceSpan

-- | 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.
newtype OverflowNatural
OverflowNatural :: Natural -> OverflowNatural
[unOverflowNatural] :: OverflowNatural -> Natural

-- | 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 Text
--    deriving (Eq, Show, PersistFieldSql)
--   
--   mkSSN :: Text -> Either Text 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.
--   
class PersistField a
toPersistValue :: PersistField a => a -> PersistValue
fromPersistValue :: PersistField a => PersistValue -> Either Text 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.
class SafeToInsert a

-- | 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.
class SymbolToField (sym :: Symbol) rec typ | sym rec -> typ
symbolToField :: SymbolToField sym rec typ => EntityField rec typ

-- | 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.
data Entity record
Entity :: Key record -> record -> Entity record
[entityKey] :: Entity record -> Key record
[entityVal] :: Entity record -> record

-- | Value to filter with. Highly dependant on the type of filter used.
data FilterValue typ
[FilterValue] :: forall typ. typ -> FilterValue typ
[FilterValues] :: forall typ. [typ] -> FilterValue typ
[UnsafeValue] :: forall a typ. PersistField a => a -> FilterValue typ

-- | Persistent allows multiple different backends (databases).
type family PersistEntityBackend record

-- | 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 family EntityField record :: Type -> Type

-- | 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.
tabulateEntity :: PersistEntity record => (forall a. () => EntityField record a -> a) -> Entity record

-- | Get list of values corresponding to given entity.
entityValues :: PersistEntity record => Entity record -> [PersistValue]

-- | Predefined toJSON. The resulting JSON looks like {"key":
--   1, "value": {"name": ...}}.
--   
--   The typical usage is:
--   
--   
--   instance ToJSON (Entity User) where
--       toJSON = keyValueEntityToJSON
--   
keyValueEntityToJSON :: (PersistEntity record, ToJSON record) => Entity record -> Value

-- | Predefined parseJSON. The input JSON looks like {"key":
--   1, "value": {"name": ...}}.
--   
--   The typical usage is:
--   
--   
--   instance FromJSON (Entity User) where
--       parseJSON = keyValueEntityFromJSON
--   
keyValueEntityFromJSON :: (PersistEntity record, FromJSON record) => Value -> Parser (Entity record)

-- | Predefined toJSON. The resulting JSON looks like {"id":
--   1, "name": ...}.
--   
--   The typical usage is:
--   
--   
--   instance ToJSON (Entity User) where
--       toJSON = entityIdToJSON
--   
entityIdToJSON :: (PersistEntity record, ToJSON record) => Entity record -> Value

-- | Predefined parseJSON. The input JSON looks like {"id": 1,
--   "name": ...}.
--   
--   The typical usage is:
--   
--   
--   instance FromJSON (Entity User) where
--       parseJSON = entityIdFromJSON
--   
entityIdFromJSON :: (PersistEntity record, FromJSON record) => Value -> Parser (Entity record)

-- | 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
--   
toPersistValueJSON :: ToJSON a => a -> PersistValue

-- | 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
--   
fromPersistValueJSON :: FromJSON a => PersistValue -> Either Text a
class PersistCore backend where {
    data BackendKey backend;
}
data family BackendKey backend

-- | 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.
class (PersistEntity record, PersistEntityBackend record ~ backend, PersistCore backend) => ToBackendKey backend record
toBackendKey :: ToBackendKey backend record => Key record -> BackendKey backend
fromBackendKey :: ToBackendKey backend record => BackendKey backend -> Key record

-- | A convenient alias for common type signatures
type PersistRecordBackend record backend = (PersistEntity record, PersistEntityBackend record ~ BaseBackend backend)

-- | 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
--   
class BackendCompatible sup sub
projectBackend :: BackendCompatible sup sub => sub -> sup

-- | 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.
class HasPersistBackend backend => IsPersistBackend backend

-- | 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 
class HasPersistBackend backend where {
    type BaseBackend backend;
}
persistBackend :: HasPersistBackend backend => backend -> BaseBackend backend
type family BaseBackend backend

-- | 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.
withBaseBackend :: forall backend (m :: Type -> Type) a. HasPersistBackend backend => ReaderT (BaseBackend backend) m a -> ReaderT backend 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.
withCompatibleBackend :: forall sup sub (m :: Type -> Type) a. BackendCompatible sup sub => ReaderT sup m a -> ReaderT sub m a
liftPersist :: (MonadIO m, MonadReader backend m) => ReaderT backend IO b -> m b

-- | 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.
getJust :: forall record backend (m :: Type -> Type). (PersistStoreRead backend, PersistRecordBackend record backend, MonadIO m) => Key record -> ReaderT backend m 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 |
--   +----+------+-----+
--   
getJustEntity :: forall record backend (m :: Type -> Type). (PersistEntityBackend record ~ BaseBackend backend, MonadIO m, PersistEntity record, PersistStoreRead backend) => Key record -> ReaderT backend m (Entity record)

-- | Curry this to make a convenience function that loads an associated
--   model.
--   
--   
--   foreign = belongsTo foreignId
--   
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)

-- | Same as belongsTo, but uses getJust and therefore is
--   similarly unsafe.
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

-- | 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 |
--   +----+---------+-----+
--   
insertEntity :: forall e backend (m :: Type -> Type). (PersistStoreWrite backend, PersistRecordBackend e backend, SafeToInsert e, MonadIO m, HasCallStack) => e -> ReaderT backend m (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 |
--   +----+------+-----+
--   
getEntity :: forall e backend (m :: Type -> Type). (PersistStoreRead backend, PersistRecordBackend e backend, MonadIO m) => Key e -> ReaderT backend m (Maybe (Entity e))

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

-- | 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.
data SqlBackend

-- | 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.
class PersistEntity record => AtLeastOneUniqueKey record
requireUniquesP :: AtLeastOneUniqueKey record => record -> NonEmpty (Unique record)

-- | This is an error message. It is used when an entity has multiple
--   unique keys, and the function expects a single unique key.
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 writing instances of
--   OnlyOneUniqueKey for an entity that has no unique keys.
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 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.
class PersistEntity record => OnlyOneUniqueKey record
onlyUniqueP :: OnlyOneUniqueKey record => record -> Unique record

-- | 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.
class PersistStoreRead backend => PersistUniqueRead backend

-- | 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 |
--   +----+------+-----+
--   
getBy :: forall record (m :: Type -> Type). (PersistUniqueRead backend, MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m (Maybe (Entity record))

-- | 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.
existsBy :: forall record (m :: Type -> Type). (PersistUniqueRead backend, MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m Bool

-- | Given a proxy for a PersistEntity record, this returns the sole
--   UniqueDef for that entity.
onlyOneUniqueDef :: (OnlyOneUniqueKey record, Monad proxy) => proxy record -> UniqueDef

-- | 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 |
--   +----+-------+-----+
--   
insertUniqueEntity :: forall record backend (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, PersistUniqueWrite backend, SafeToInsert record) => record -> ReaderT backend m (Maybe (Entity 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.
onlyUnique :: forall record backend (m :: Type -> Type). (MonadIO m, PersistUniqueWrite backend, PersistRecordBackend record backend, OnlyOneUniqueKey record) => record -> ReaderT backend m (Unique 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 |
--   +----+------+-----+
--   
getByValue :: forall record (m :: Type -> Type) backend. (MonadIO m, PersistUniqueRead backend, PersistRecordBackend record backend, AtLeastOneUniqueKey record) => record -> ReaderT backend m (Maybe (Entity 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
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))

-- | 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
--   
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 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
--   
checkUniqueUpdateable :: forall record backend (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, PersistUniqueRead backend) => Entity record -> ReaderT backend m (Maybe (Unique record))

-- | Backends supporting conditional write operations
class (PersistQueryRead backend, PersistStoreWrite backend) => PersistQueryWrite backend

-- | Update individual fields on any record matching the given criterion.
updateWhere :: forall (m :: Type -> Type) record. (PersistQueryWrite backend, MonadIO m, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> ReaderT backend m ()

-- | Delete all records matching the given criterion.
deleteWhere :: forall (m :: Type -> Type) record. (PersistQueryWrite backend, MonadIO m, PersistRecordBackend record backend) => [Filter record] -> ReaderT backend m ()

-- | Backends supporting conditional read operations.
class (PersistCore backend, PersistStoreRead backend) => PersistQueryRead backend

-- | 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.
selectSourceRes :: forall record (m1 :: Type -> Type) (m2 :: Type -> Type). (PersistQueryRead backend, PersistRecordBackend record backend, MonadIO m1, MonadIO m2) => [Filter record] -> [SelectOpt record] -> ReaderT backend m1 (Acquire (ConduitM () (Entity record) m2 ()))

-- | Get just the first record for the criterion.
selectFirst :: forall (m :: Type -> Type) record. (PersistQueryRead backend, MonadIO m, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))

-- | Get the Keys of all records matching the given criterion.
selectKeysRes :: forall (m1 :: Type -> Type) (m2 :: Type -> Type) record. (PersistQueryRead backend, 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.
--   
--   For an example, see selectList.
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 ()

-- | 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 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 backend which is a wrapper around SqlBackend.
type IsSqlBackend backend = (IsPersistBackend backend, BaseBackend backend ~ SqlBackend)

-- | Like SqlPersistT but compatible with any SQL backend which
--   can handle read and write queries.
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 queries.
type SqlReadT (m :: Type -> Type) a = forall backend. SqlBackendCanRead backend => ReaderT backend m a

-- | A constraint synonym which witnesses that a backend is SQL and can run
--   read and write 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 queries.
type SqlBackendCanRead backend = (BackendCompatible SqlBackend backend, PersistQueryRead backend, PersistStoreRead backend, PersistUniqueRead backend)

-- | An SQL backend which can handle read or write queries
--   
--   The constructor was exposed in 2.10.0
newtype SqlWriteBackend
SqlWriteBackend :: SqlBackend -> SqlWriteBackend
[unSqlWriteBackend] :: SqlWriteBackend -> SqlBackend

-- | An SQL backend which can only handle read queries
--   
--   The constructor was exposed in 2.10.0.
newtype SqlReadBackend
SqlReadBackend :: SqlBackend -> SqlReadBackend
[unSqlReadBackend] :: SqlReadBackend -> SqlBackend

-- | Useful for running a write query against an untagged backend with
--   unknown capabilities.
writeToUnknown :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlWriteBackend m a -> ReaderT SqlBackend m a

-- | Useful for running a read query against a backend with read and write
--   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 unknown
--   capabilities.
readToUnknown :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlReadBackend m a -> ReaderT SqlBackend m a

-- | Values to configure a pool of database connections. See
--   Data.Pool for details.
data ConnectionPoolConfig
ConnectionPoolConfig :: Int -> NominalDiffTime -> Int -> ConnectionPoolConfig

-- | How many stripes to divide the pool into. See Data.Pool for
--   details. Default: 1.
[connectionPoolConfigStripes] :: ConnectionPoolConfig -> Int

-- | How long connections can remain idle before being disposed of, in
--   seconds. Default: 600
[connectionPoolConfigIdleTimeout] :: ConnectionPoolConfig -> NominalDiffTime

-- | How many connections should be held in the connection pool. Default:
--   10
[connectionPoolConfigSize] :: ConnectionPoolConfig -> Int
type ConnectionPool = Pool SqlBackend
type SqlPersistM = SqlPersistT NoLoggingT ResourceT IO
type SqlPersistT = ReaderT SqlBackend
data PersistentSqlException
StatementAlreadyFinalized :: Text -> PersistentSqlException
Couldn'tGetSQLConnection :: PersistentSqlException

-- | This value specifies how a field references another table.
data ColumnReference
ColumnReference :: !EntityNameDB -> !ConstraintNameDB -> !FieldCascade -> ColumnReference

-- | The table name that the
[crTableName] :: ColumnReference -> !EntityNameDB

-- | The name of the foreign key constraint.
[crConstraintName] :: ColumnReference -> !ConstraintNameDB

-- | Whether or not updates/deletions to the referenced table cascade to
--   this table.
[crFieldCascade] :: ColumnReference -> !FieldCascade

-- | Initializes a ConnectionPoolConfig with default values. See the
--   documentation of ConnectionPoolConfig for each field's default
--   value.
defaultConnectionPoolConfig :: ConnectionPoolConfig

-- | 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.
data BackendSpecificOverrides

-- | 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
getBackendSpecificForeignKeyName :: BackendSpecificOverrides -> Maybe (EntityNameDB -> FieldNameDB -> ConstraintNameDB)

-- | Set the backend's foreign key generation function to this value.
setBackendSpecificForeignKeyName :: (EntityNameDB -> FieldNameDB -> ConstraintNameDB) -> BackendSpecificOverrides -> BackendSpecificOverrides

-- | Creates an empty BackendSpecificOverrides (i.e. use the default
--   behavior; no overrides)
emptyBackendSpecificOverrides :: BackendSpecificOverrides
defaultAttribute :: [FieldAttr] -> Maybe Text

-- | Create the list of columns for the given entity.
mkColumns :: [EntityDef] -> EntityDef -> BackendSpecificOverrides -> ([Column], [UniqueDef], [ForeignDef])

-- | A more general way to convert instances of ToJSON type class to
--   strict text Text.
toJsonText :: ToJSON j => j -> Text

-- | 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"
--   
class PersistField a => PersistFieldSql a
sqlType :: PersistFieldSql a => Proxy a -> SqlType

-- | 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.
newtype EntityWithPrefix (prefix :: Symbol) record
EntityWithPrefix :: Entity record -> EntityWithPrefix (prefix :: Symbol) record
[unEntityWithPrefix] :: EntityWithPrefix (prefix :: Symbol) record -> Entity record

-- | Class for data types that may be retrived from a rawSql
--   query.
class RawSql a

-- | Number of columns that this data type needs and the list of
--   substitutions for SELECT placeholders ??.
rawSqlCols :: RawSql a => (Text -> Text) -> a -> (Int, [Text])

-- | A string telling the user why the column count is what it is.
rawSqlColCountReason :: RawSql a => a -> String

-- | Transform a row of the result into the data type.
rawSqlProcessRow :: RawSql a => [PersistValue] -> Either Text a

-- | 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"
--   
unPrefix :: forall (prefix :: Symbol) record. EntityWithPrefix prefix record -> Entity record
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 ()))

-- | Execute a raw SQL statement
rawExecute :: forall (m :: Type -> Type) backend. (MonadIO m, BackendCompatible SqlBackend backend) => Text -> [PersistValue] -> ReaderT backend m ()

-- | Execute a raw SQL statement and return the number of rows it has
--   modified.
rawExecuteCount :: forall (m :: Type -> Type) backend. (MonadIO m, BackendCompatible SqlBackend backend) => Text -> [PersistValue] -> ReaderT backend m Int64
getStmtConn :: SqlBackend -> Text -> IO Statement

-- | 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.
runSqlPool :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> m a

-- | Like runSqlPool, but supports specifying an isolation level.
runSqlPoolWithIsolation :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> IsolationLevel -> m a

-- | Like runSqlPool, but does not surround the action in a
--   transaction. This action might leave your database in a weird state.
runSqlPoolNoTransaction :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> 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.
runSqlPoolWithHooks :: forall backend m a before after onException. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> (backend -> m before) -> (backend -> m after) -> (backend -> SomeException -> m onException) -> m a

-- | This function is how runSqlPoolWithHooks is defined.
--   
--   It's currently the most general function for using a SQL pool.
runSqlPoolWithExtensibleHooks :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> SqlPoolHooks m backend -> m a

-- | 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.
acquireSqlConn :: (MonadReader backend m, BackendCompatible SqlBackend backend) => m (Acquire backend)

-- | Like acquireSqlConn, but lets you specify an explicit isolation
--   level.
acquireSqlConnWithIsolation :: (MonadReader backend m, BackendCompatible SqlBackend backend) => IsolationLevel -> m (Acquire backend)
runSqlConn :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> backend -> m a

-- | Like runSqlConn, but supports specifying an isolation level.
runSqlConnWithIsolation :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> backend -> IsolationLevel -> m a
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 :: forall backend m a. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> Int -> (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.
withSqlPoolWithConfig :: forall backend m a. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> ConnectionPoolConfig -> (Pool backend -> m a) -> m a
createSqlPool :: forall backend m. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> Int -> m (Pool backend)

-- | Creates a pool of connections to a SQL database.
createSqlPoolWithConfig :: (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> ConnectionPoolConfig -> m (Pool backend)

-- | 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}}]
--   
withSqlConn :: forall backend m a. (MonadUnliftIO m, MonadLoggerIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> (backend -> m a) -> m a
close' :: BackendCompatible SqlBackend backend => backend -> IO ()
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

-- | 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
getTableName :: forall record (m :: Type -> Type) backend. (PersistEntity record, BackendCompatible SqlBackend backend, Monad m) => record -> ReaderT backend m Text

-- | useful for a backend to implement tableName by adding escaping
tableDBName :: PersistEntity record => record -> EntityNameDB

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

-- | useful for a backend to implement fieldName by adding escaping
fieldDBName :: PersistEntity record => EntityField record typ -> FieldNameDB

-- | Used when determining how to prefix a column name in a WHERE
--   clause.
data FilterTablePrefix

-- | Prefix the column with the table name. This is useful if the column
--   name might be ambiguous.
PrefixTableName :: FilterTablePrefix

-- | 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.
PrefixExcluded :: FilterTablePrefix

-- | Render a [Filter record] into a Text value
--   suitable for inclusion into a SQL query.
filterClause :: PersistEntity val => Maybe FilterTablePrefix -> SqlBackend -> [Filter val] -> Text

-- | 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.
filterClauseWithVals :: PersistEntity val => Maybe FilterTablePrefix -> SqlBackend -> [Filter val] -> (Text, [PersistValue])

-- | Render a [SelectOpt record] made up *only* of
--   Asc and Desc constructors into a Text value
--   suitable for inclusion into a SQL query.
orderClause :: PersistEntity val => Maybe FilterTablePrefix -> SqlBackend -> [SelectOpt val] -> Text

-- | Generates sql for limit and offset for postgres, sqlite and mysql.
decorateSQLWithLimitOffset :: Text -> (Int, Int) -> Text -> Text

-- | 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.
newtype PersistUnsafeMigrationException
PersistUnsafeMigrationException :: [(Bool, Sql)] -> PersistUnsafeMigrationException

-- | 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 Migration = WriterT [Text] WriterT CautiousMigration ReaderT SqlBackend IO ()

-- | 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 CautiousMigration = [(Bool, Sql)]
type Sql = Text

-- | 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 (Either [Text] CautiousMigration)

-- | Like parseMigration, but instead of returning the value in an
--   Either value, it calls error on the error values.
parseMigration' :: forall (m :: Type -> Type). (HasCallStack, MonadIO m) => Migration -> ReaderT SqlBackend m CautiousMigration

-- | Prints a migration.
printMigration :: forall (m :: Type -> Type). (HasCallStack, MonadIO m) => Migration -> ReaderT SqlBackend m ()

-- | Convert a Migration to a list of Text values
--   corresponding to their Sql statements.
showMigration :: forall (m :: Type -> Type). (HasCallStack, MonadIO m) => Migration -> ReaderT SqlBackend m [Text]

-- | Return all of the Sql values associated with the given
--   migration. Calls error if there's a parse error on any
--   migration.
getMigration :: forall (m :: Type -> Type). (MonadIO m, HasCallStack) => Migration -> ReaderT SqlBackend m [Sql]

-- | Runs a migration. If the migration fails to parse or if any of the
--   migrations are unsafe, then this throws a
--   PersistUnsafeMigrationException.
runMigration :: forall (m :: Type -> Type). MonadIO m => Migration -> ReaderT SqlBackend m ()

-- | 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
runMigrationQuiet :: forall (m :: Type -> Type). MonadIO 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!
runMigrationSilent :: forall (m :: Type -> Type). MonadUnliftIO m => Migration -> ReaderT SqlBackend m [Text]

-- | Like runMigration, but this will perform the unsafe database
--   migrations instead of erroring out.
runMigrationUnsafe :: forall (m :: Type -> Type). MonadIO m => Migration -> ReaderT SqlBackend m ()

-- | Same as runMigrationUnsafe, but returns a list of the SQL
--   commands executed instead of printing them to stderr.
runMigrationUnsafeQuiet :: forall (m :: Type -> Type). (HasCallStack, MonadIO m) => Migration -> ReaderT SqlBackend m [Text]

-- | Report multiple errors in a Migration.
reportErrors :: [Text] -> Migration

-- | Add a migration to the migration plan.
addMigration :: Bool -> Sql -> Migration

-- | Add a CautiousMigration (aka a [(Bool,
--   Text)]) to the migration plan.
addMigrations :: CautiousMigration -> 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";" []
--   
runSqlCommand :: SqlPersistT IO () -> Migration

-- | 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).
transactionSave :: forall (m :: Type -> Type). MonadIO m => ReaderT SqlBackend m ()

-- | Commit the current transaction and begin a new one with the specified
--   isolation level.
transactionSaveWithIsolation :: forall (m :: Type -> Type). MonadIO m => IsolationLevel -> 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.
transactionUndo :: forall (m :: Type -> Type). MonadIO m => ReaderT SqlBackend m ()

-- | Roll back the current transaction and begin a new one with the
--   specified isolation level.
transactionUndoWithIsolation :: forall (m :: Type -> Type). MonadIO m => IsolationLevel -> ReaderT SqlBackend m ()

-- | This module contain MySQL-specific functions.
module Database.Esqueleto.MySQL

-- | (random()) Split out into database specific modules because
--   MySQL uses `rand()`.
random_ :: (PersistField a, Num a) => SqlExpr (Value a)

-- | LOCK IN SHARE MODE syntax.
--   
--   Example:
--   
--   
--   locking lockInShareMode
--   
lockInShareMode :: LockingKind

-- | This module contain PostgreSQL-specific functions.
module Database.Esqueleto.PostgreSQL

-- | Aggregate mode
data AggMode

-- | ALL
AggModeAll :: AggMode

-- | DISTINCT
AggModeDistinct :: AggMode

-- | (array_agg) Concatenate distinct input values, including
--   NULLs, into an array.
arrayAggDistinct :: (PersistField a, PersistField [a]) => SqlExpr (Value a) -> SqlExpr (Value (Maybe [a]))
arrayAgg :: PersistField a => SqlExpr (Value a) -> SqlExpr (Value (Maybe [a]))
arrayAggWith :: AggMode -> SqlExpr (Value a) -> [OrderByClause] -> SqlExpr (Value (Maybe [a]))

-- | (array_remove) Remove all elements equal to the given value
--   from the array.
arrayRemove :: SqlExpr (Value [a]) -> SqlExpr (Value a) -> SqlExpr (Value [a])

-- | Remove NULL values from an array
arrayRemoveNull :: SqlExpr (Value [Maybe a]) -> SqlExpr (Value [a])

-- | (string_agg) Concatenate input values separated by a
--   delimiter.
stringAgg :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s) -> SqlExpr (Value (Maybe s))

-- | (string_agg) Concatenate input values separated by a
--   delimiter.
stringAggWith :: SqlString s => AggMode -> SqlExpr (Value s) -> SqlExpr (Value s) -> [OrderByClause] -> SqlExpr (Value (Maybe s))

-- | Coalesce an array with an empty default value
maybeArray :: (PersistField a, PersistField [a]) => SqlExpr (Value (Maybe [a])) -> SqlExpr (Value [a])

-- | (chr) Translate the given integer to a character. (Note the
--   result will depend on the character set of your database.)
chr :: SqlString s => SqlExpr (Value Int) -> SqlExpr (Value s)
now_ :: SqlExpr (Value UTCTime)

-- | (random()) Split out into database specific modules because
--   MySQL uses `rand()`.
random_ :: (PersistField a, Num a) => SqlExpr (Value a)

-- | Perform an upsert operation on the given record.
--   
--   If the record exists in the database already, then the updates will be
--   performed on that record. If the record does not exist, then the
--   provided record will be inserted.
--   
--   If you wish to provide an empty list of updates (ie "if the record
--   exists, do nothing"), then you will need to call upsertMaybe.
--   Postgres will not return anything if there are no modifications or
--   inserts made.
upsert :: forall (m :: Type -> Type) record. (MonadIO m, PersistEntity record, OnlyOneUniqueKey record, PersistRecordBackend record SqlBackend, IsPersistBackend (PersistEntityBackend record)) => record -> NonEmpty (SqlExpr (Entity record) -> SqlExpr Update) -> ReaderT SqlBackend m (Entity record)

-- | Like upsert, but permits an empty list of updates to be
--   performed.
--   
--   If no updates are provided and the record already was present in the
--   database, then this will return Nothing. If you want to fetch
--   the record out of the database, you can write:
--   
--   
--   mresult <- upsertMaybe record []
--   case mresult of
--       Nothing ->
--           getBy (onlyUniqueP record)
--       Just res ->
--           pure (Just res)
--   
upsertMaybe :: forall (m :: Type -> Type) record. (MonadIO m, PersistEntity record, OnlyOneUniqueKey record, PersistRecordBackend record SqlBackend, IsPersistBackend (PersistEntityBackend record)) => record -> [SqlExpr (Entity record) -> SqlExpr Update] -> ReaderT SqlBackend m (Maybe (Entity record))
upsertBy :: forall (m :: Type -> Type) record. (MonadIO m, PersistEntity record, IsPersistBackend (PersistEntityBackend record), HasCallStack) => Unique record -> record -> NonEmpty (SqlExpr (Entity record) -> SqlExpr Update) -> ReaderT SqlBackend m (Entity record)

-- | Attempt to insert a record into the database. If the
--   record already exists for the given Unique
--   record, then a list of updates will be performed.
--   
--   If you provide an empty list of updates, then this function will
--   return Nothing if the record already exists in the database.
upsertMaybeBy :: forall (m :: Type -> Type) record. (MonadIO m, PersistEntity record, IsPersistBackend (PersistEntityBackend record)) => Unique record -> record -> [SqlExpr (Entity record) -> SqlExpr Update] -> ReaderT SqlBackend m (Maybe (Entity record))

-- | Inserts into a table the results of a query similar to
--   insertSelect but allows to update values that violate a
--   constraint during insertions.
--   
--   Example of usage:
--   
--   
--   mkPersist sqlSettings [persistLowerCase|
--     Bar
--       num Int
--       deriving Eq Show
--     Foo
--       num Int
--       UniqueFoo num
--       deriving Eq Show
--   |]
--   
--   action = do
--       insertSelectWithConflict
--           UniqueFoo -- (UniqueFoo undefined) or (UniqueFoo anyNumber) would also work
--           (do
--               b <- from $ table @Bar
--               return $ Foo <# (b ^. BarNum)
--           )
--           (\current excluded ->
--               [FooNum =. (current ^. FooNum) +. (excluded ^. FooNum)]
--           )
--   
--   
--   Inserts to table Foo all Bar.num values and in case
--   of conflict SomeFooUnique, the conflicting value is updated
--   to the current plus the excluded.
insertSelectWithConflict :: forall a (m :: Type -> Type) val backend. (FinalResult a, KnowResult a ~ Unique val, MonadIO m, PersistEntity val, SqlBackendCanWrite backend) => a -> SqlQuery (SqlExpr (Insertion val)) -> (SqlExpr (Entity val) -> SqlExpr (Entity val) -> [SqlExpr (Entity val) -> SqlExpr Update]) -> ReaderT backend m ()

-- | Same as insertSelectWithConflict but returns the number of rows
--   affected.
insertSelectWithConflictCount :: forall a val (m :: Type -> Type) backend. (FinalResult a, KnowResult a ~ Unique val, MonadIO m, PersistEntity val, SqlBackendCanWrite backend) => a -> SqlQuery (SqlExpr (Insertion val)) -> (SqlExpr (Entity val) -> SqlExpr (Entity val) -> [SqlExpr (Entity val) -> SqlExpr Update]) -> ReaderT backend m Int64

-- | NOWAIT syntax for postgres locking error will be thrown if
--   locked rows are attempted to be selected
noWait :: OnLockedBehavior

-- | default behaviour of postgres locks. will attempt to wait for locks to
--   expire
wait :: OnLockedBehavior

-- | `SKIP LOCKED` syntax for postgres locking locked rows will be skipped
skipLocked :: OnLockedBehavior

-- | `FOR UPDATE OF` syntax for postgres locking allows locking of specific
--   tables with an update lock in a view or join
forUpdateOf :: LockableEntity a => a -> OnLockedBehavior -> SqlQuery ()

-- | `FOR NO KEY UPDATE OF` syntax for postgres locking allows locking of
--   specific tables with a no key update lock in a view or join
forNoKeyUpdateOf :: LockableEntity a => a -> OnLockedBehavior -> SqlQuery ()

-- | FOR SHARE syntax for Postgres locking.
--   
--   Example use:
--   
--   
--   locking forShare
--   
forShare :: LockingKind

-- | `FOR SHARE OF` syntax for postgres locking allows locking of specific
--   tables with a share lock in a view or join
forShareOf :: LockableEntity a => a -> OnLockedBehavior -> SqlQuery ()

-- | `FOR KEY SHARE OF` syntax for postgres locking allows locking of
--   specific tables with a key share lock in a view or join
forKeyShareOf :: LockableEntity a => a -> OnLockedBehavior -> SqlQuery ()

-- | Allow aggregate functions to take a filter clause.
--   
--   Example of usage:
--   
--   
--   share [mkPersist sqlSettings] [persistLowerCase|
--     User
--       name Text
--       deriving Eq Show
--     Task
--       userId UserId
--       completed Bool
--       deriving Eq Show
--   |]
--   
--   select $ from $ (users InnerJoin tasks) -> do
--     on $ users ^. UserId ==. tasks ^. TaskUserId
--     groupBy $ users ^. UserId
--     return
--      ( users ^. UserId
--      , count (tasks ^. TaskId) filterWhere (tasks ^. TaskCompleted ==. val True)
--      , count (tasks ^. TaskId) filterWhere (tasks ^. TaskCompleted ==. val False)
--      )
--   
filterWhere :: SqlExpr (Value a) -> SqlExpr (Value Bool) -> SqlExpr (Value a)

-- | Allows to use `VALUES (..)` in-memory set of values in RHS of
--   from expressions. Useful for JOIN's on known values which
--   also can be additionally preprocessed somehow on db side with usage of
--   inner PostgreSQL capabilities.
--   
--   Example of usage:
--   
--   
--   share [mkPersist sqlSettings] [persistLowerCase|
--     User
--       name Text
--       age Int
--       deriving Eq Show
--   
--   select $ do
--    bound :& user <- from $
--        values (   (val (10 :: Int), val ("ten" :: Text))
--              :| [ (val 20, val "twenty")
--                 , (val 30, val "thirty") ]
--              )
--        InnerJoin table User
--        on (((bound, _boundName) :& user) -> user^.UserAge >=. bound)
--    groupBy bound
--    pure (bound, count @Int $ user^.UserName)
--   
values :: (ToSomeValues a, ToAliasReference a, ToAlias a) => NonEmpty a -> From a

-- | ILIKE operator (case-insensitive LIKE).
ilike :: SqlString s => SqlExpr (Value s) -> SqlExpr (Value s) -> SqlExpr (Value Bool)
infixr 2 `ilike`

-- | DISTINCT ON. Change the current SELECT into
--   SELECT DISTINCT ON (SqlExpressions). For example:
--   
--   
--   select $ do
--     foo <- from $ table @Foo
--     distinctOn [don (foo ^. FooName), don (foo ^. FooState)]
--     pure foo
--   
--   
--   You can also chain different calls to distinctOn. The above is
--   equivalent to:
--   
--   
--   select $ do
--     foo <- from $ table @Foo
--     distinctOn [don (foo ^. FooName)]
--     distinctOn [don (foo ^. FooState)]
--     pure foo
--   
--   
--   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.
distinctOn :: [SqlExpr DistinctOn] -> SqlQuery ()

-- | A convenience function that calls both distinctOn and
--   orderBy. In other words,
--   
--   
--   distinctOnOrderBy [asc foo, desc bar, desc quux]
--   
--   
--   is the same as:
--   
--   
--   distinctOn [don foo, don  bar, don  quux]
--   orderBy  [asc foo, desc bar, desc quux]
--     ...
--   
distinctOnOrderBy :: [SqlExpr OrderBy] -> SqlQuery ()

-- | WITH MATERIALIZED clause is used to introduce a
--   Common Table Expression (CTE) with the MATERIALIZED keyword.
--   The MATERIALIZED keyword is only supported in PostgreSQL >= version
--   12. In Esqueleto, CTEs should be used as a subquery memoization
--   tactic. PostgreSQL treats a materialized CTE as an optimization fence.
--   A materialized CTE is always fully calculated, and is not "inlined"
--   with other table joins. Without the MATERIALIZED keyword, PostgreSQL
--   >= 12 may "inline" the CTE as though it was any other join. You
--   should always verify that using a materialized CTE will in fact
--   improve your performance over a regular subquery.
--   
--   
--   select $ do
--   cte <- withMaterialized subQuery
--   cteResult <- from cte
--   where_ $ cteResult ...
--   pure cteResult
--   
--   
--   For more information on materialized CTEs, see the PostgreSQL manual
--   documentation on Common Table Expression Materialization.
withMaterialized :: (ToAlias a, ToAliasReference a, SqlSelect a r) => SqlQuery a -> SqlQuery (From a)

-- | WITH NOT MATERIALIZED clause is used to
--   introduce a Common Table Expression (CTE) with the NOT
--   MATERIALIZED keywords. These are only supported in PostgreSQL >=
--   version 12. In Esqueleto, CTEs should be used as a subquery
--   memoization tactic. PostgreSQL treats a materialized CTE as an
--   optimization fence. A MATERIALIZED CTE is always fully calculated, and
--   is not "inlined" with other table joins. Sometimes, this is
--   undesirable, so postgres provides the NOT MATERIALIZED modifier to
--   prevent this behavior, thus enabling it to possibly decide to treat
--   the CTE as any other join.
--   
--   Given the above, it is unlikely that this function will be useful, as
--   a normal join should be used instead, but is provided for
--   completeness.
--   
--   
--   select $ do
--   cte <- withNotMaterialized subQuery
--   cteResult <- from cte
--   where_ $ cteResult ...
--   pure cteResult
--   
--   
--   For more information on materialized CTEs, see the PostgreSQL manual
--   documentation on Common Table Expression Materialization.
withNotMaterialized :: (ToAlias a, ToAliasReference a, SqlSelect a r) => SqlQuery a -> SqlQuery (From a)

-- | Ascending order of this field or SqlExpression with nulls coming
--   first.
ascNullsFirst :: PersistField a => SqlExpr (Value a) -> SqlExpr OrderBy

-- | Ascending order of this field or SqlExpression with nulls coming last.
--   Note that this is the same as normal ascending ordering in Postgres,
--   but it has been included for completeness.
ascNullsLast :: PersistField a => SqlExpr (Value a) -> SqlExpr OrderBy

-- | Descending order of this field or SqlExpression with nulls coming
--   first. Note that this is the same as normal ascending ordering in
--   Postgres, but it has been included for completeness.
descNullsFirst :: PersistField a => SqlExpr (Value a) -> SqlExpr OrderBy

-- | Descending order of this field or SqlExpression with nulls coming
--   last.
descNullsLast :: PersistField a => SqlExpr (Value a) -> SqlExpr OrderBy

-- | (Internal) Create a custom aggregate functions with aggregate mode
--   
--   Do not use this function directly, instead define a new
--   function and give it a type (see unsafeSqlBinOp)
unsafeSqlAggregateFunction :: UnsafeSqlFunctionArgument a => Builder -> AggMode -> a -> [OrderByClause] -> SqlExpr (Value b)
instance GHC.Internal.Show.Show Database.Esqueleto.PostgreSQL.AggMode

-- | This module contains PostgreSQL-specific JSON functions.
--   
--   A couple of things to keep in mind about this module:
--   
--   
--   
- The Type column in the PostgreSQL documentation tables
--   are the types of the right operand, the left is always
--   jsonb.
--   
- Since these operators can all take NULL values as their
--   input, and most can also output NULL values (even when the
--   inputs are guaranteed to not be NULL), all JSONB values are
--   wrapped in Maybe. This also makes it easier to chain them. (cf.
--   JSONBExpr) Just use the just function to lift any
--   non-Maybe JSONB values in case it doesn't type check.
--   
- As long as the previous operator's resulting value is a
--   JSONBExpr, any other JSON operator can be used to transform the
--   JSON further. (e.g. [1,2,3] -> 1 @> 2)
--   
--   
--   The PostgreSQL version the functions work with are included
--   in their description.
module Database.Esqueleto.PostgreSQL.JSON

-- | Newtype wrapper around any type with a JSON representation.
newtype JSONB a
JSONB :: a -> JSONB a
[unJSONB] :: JSONB a -> a

-- | SqlExpr of a NULL-able JSONB value. Hence the
--   Maybe.
--   
--   Note: NULL here is a PostgreSQL NULL, not a JSON null
type JSONBExpr a = SqlExpr Value Maybe JSONB a

-- | Convenience function to lift a regular value into a JSONB
--   expression.
jsonbVal :: (FromJSON a, ToJSON a) => a -> JSONBExpr a

-- | Used with certain JSON operators.
--   
--   This data type has Num and IsString instances for ease
--   of use by using integer and string literals.
--   
--   
--   >>> 3 :: JSONAccessor
--   JSONIndex 3
--   
--   >>> -3 :: JSONAccessor
--   JSONIndex -3
--   
--   
--   
--   >>> "name" :: JSONAccessor
--   JSONKey "name"
--   
--   
--   NOTE: DO NOT USE ANY OF THE Num METHODS ON THIS TYPE!
data JSONAccessor
JSONIndex :: Int -> JSONAccessor
JSONKey :: Text -> JSONAccessor

-- | Requires PostgreSQL version >= 9.3
--   
--   This function extracts the jsonb value from a JSON array or object,
--   depending on whether you use an int or a text. (cf.
--   JSONAccessor)
--   
--   As long as the left operand is jsonb, this function will not
--   throw an exception, but will return NULL when an int
--   is used on anything other than a JSON array, or a text is
--   used on anything other than a JSON object.
--   
--   
PostgreSQL Documentation
--   
--   
--       | Type | Description                                |  Example                                         | Example Result
--   ----+------+--------------------------------------------+--------------------------------------------------+----------------
--    -> | int  | Get JSON array element (indexed from zero) | '[{"a":"foo"},{"b":"bar"},{"c":"baz"}]'::json->2 | {"c":"baz"}
--    -> | text | Get JSON object field by key               | '{"a": {"b":"foo"}}'::json->a                  | {"b":"foo"}
--   
(->.) :: JSONBExpr a -> JSONAccessor -> JSONBExpr b
infixl 6 ->.

-- | Requires PostgreSQL version >= 9.3
--   
--   Identical to ->., but the resulting DB type is a
--   text, so it could be chained with anything that uses
--   text.
--   
--   CAUTION: if the "scalar" JSON value null is the result
--   of this function, PostgreSQL will interpret it as a
--   PostgreSQL NULL value, and will therefore be
--   Nothing instead of (Just "null")
--   
--   
PostgreSQL Documentation
--   
--   
--        | Type | Description                    |  Example                    | Example Result
--   -----+------+--------------------------------+-----------------------------+----------------
--    ->> | int  | Get JSON array element as text | '[1,2,3]'::json->>2         | 3
--    ->> | text | Get JSON object field as text  | '{"a":1,"b":2}'::json->>b | 2
--   
(->>.) :: JSONBExpr a -> JSONAccessor -> SqlExpr (Value (Maybe Text))
infixl 6 ->>.

-- | Requires PostgreSQL version >= 9.3
--   
--   This operator can be used to select a JSON value from deep inside
--   another one. It only works on objects and arrays and will result in
--   NULL (Nothing) when encountering any other JSON type.
--   
--   The Texts used in the right operand list will always select an
--   object field, but can also select an index from a JSON array if that
--   text is parsable as an integer.
--   
--   Consider the following:
--   
--   
--   x ^. TestBody #>. ["0","1"]
--   
--   
--   The following JSON values in the test table's body
--   column will be affected:
--   
--   
--    Values in column                     | Resulting value
--   --------------------------------------+----------------------------
--   {"0":{"1":"Got it!"}}                 | "Got it!"
--   {"0":[null,["Got it!","Even here!"]]} | ["Got it!", "Even here!"]
--   [{"1":"Got it again!"}]               | "Got it again!"
--   [[null,{"Wow":"so deep!"}]]           | {"Wow": "so deep!"}
--   false                                 | NULL
--   "nope"                                | NULL
--   3.14                                  | NULL
--   
--   
--   
PostgreSQL Documentation
--   
--   
--        | Type   | Description                       |  Example                                   | Example Result
--   -----+--------+-----------------------------------+--------------------------------------------+----------------
--    #>  | text[] | Get JSON object at specified path | '{"a": {"b":{"c": "foo"}}}'::json#>'{a,b}' | {"c": "foo"}
--   
(#>.) :: JSONBExpr a -> [Text] -> JSONBExpr b
infixl 6 #>.

-- | Requires PostgreSQL version >= 9.3
--   
--   This function is to #>. as ->>. is to
--   ->.
--   
--   CAUTION: if the "scalar" JSON value null is the result
--   of this function, PostgreSQL will interpret it as a
--   PostgreSQL NULL value, and will therefore be
--   Nothing instead of (Just "null")
--   
--   
PostgreSQL Documentation
--   
--   
--        | Type   | Description                               |  Example                                    | Example Result
--   -----+--------+-------------------------------------------+---------------------------------------------+----------------
--    #>> | text[] | Get JSON object at specified path as text | '{"a":[1,2,3],"b":[4,5,6]}'::json#>>'{a,2}' | 3
--   
(#>>.) :: JSONBExpr a -> [Text] -> SqlExpr (Value (Maybe Text))
infixl 6 #>>.

-- | Requires PostgreSQL version >= 9.4
--   
--   This operator checks for the JSON value on the right to be a subset of
--   the JSON value on the left.
--   
--   Examples of the usage of this operator can be found in the
--   Database.Persist.Postgresql.JSON module.
--   
--   (here:
--   https://hackage.haskell.org/package/persistent-postgresql-2.10.0/docs/Database-Persist-Postgresql-JSON.html)
--   
--   
PostgreSQL Documentation
--   
--   
--       | Type  | Description                                                 |  Example
--   ----+-------+-------------------------------------------------------------+---------------------------------------------
--    @> | jsonb | Does the left JSON value contain within it the right value? | '{"a":1, "b":2}'::jsonb @> '{"b":2}'::jsonb
--   
(@>.) :: JSONBExpr a -> JSONBExpr b -> SqlExpr (Value Bool)
infixl 6 @>.

-- | Requires PostgreSQL version >= 9.4
--   
--   This operator works the same as @>., just with the arguments
--   flipped. So it checks for the JSON value on the left to be a subset of
--   JSON value on the right.
--   
--   Examples of the usage of this operator can be found in the
--   Database.Persist.Postgresql.JSON module.
--   
--   (here:
--   https://hackage.haskell.org/package/persistent-postgresql-2.10.0/docs/Database-Persist-Postgresql-JSON.html)
--   
--   
PostgreSQL Documentation
--   
--   
--       | Type  | Description                                              |  Example
--   ----+-------+----------------------------------------------------------+---------------------------------------------
--    <@ | jsonb | Is the left JSON value contained within the right value? | '{"b":2}'::jsonb <@ '{"a":1, "b":2}'::jsonb
--   
(<@.) :: JSONBExpr a -> JSONBExpr b -> SqlExpr (Value Bool)
infixl 6 <@.

-- | Requires PostgreSQL version >= 9.4
--   
--   This operator checks if the given text is a top-level member of the
--   JSON value on the left. This means a top-level field in an object, a
--   top-level string in an array or just a string value.
--   
--   Examples of the usage of this operator can be found in the
--   Database.Persist.Postgresql.JSON module.
--   
--   (here:
--   https://hackage.haskell.org/package/persistent-postgresql-2.10.0/docs/Database-Persist-Postgresql-JSON.html)
--   
--   
PostgreSQL Documentation
--   
--   
--      | Type | Description                                                     |  Example
--   ---+------+-----------------------------------------------------------------+-------------------------------
--    ? | text | Does the string exist as a top-level key within the JSON value? | '{"a":1, "b":2}'::jsonb ? b
--   
(?.) :: JSONBExpr a -> Text -> SqlExpr (Value Bool)
infixl 6 ?.

-- | Requires PostgreSQL version >= 9.4
--   
--   This operator checks if ANY of the given texts is a top-level
--   member of the JSON value on the left. This means any top-level field
--   in an object, any top-level string in an array or just a string value.
--   
--   Examples of the usage of this operator can be found in the
--   Database.Persist.Postgresql.JSON module.
--   
--   (here:
--   https://hackage.haskell.org/package/persistent-postgresql-2.10.0/docs/Database-Persist-Postgresql-JSON.html)
--   
--   
PostgreSQL Documentation
--   
--   
--       | Type   | Description                                            |  Example
--   ----+--------+--------------------------------------------------------+---------------------------------------------------
--    ?| | text[] | Do any of these array strings exist as top-level keys? | '{"a":1, "b":2, "c":3}'::jsonb ?| array[b, c]
--   
(?|.) :: JSONBExpr a -> [Text] -> SqlExpr (Value Bool)
infixl 6 ?|.

-- | Requires PostgreSQL version >= 9.4
--   
--   This operator checks if ALL of the given texts are top-level
--   members of the JSON value on the left. This means a top-level field in
--   an object, a top-level string in an array or just a string value.
--   
--   Examples of the usage of this operator can be found in the
--   Database.Persist.Postgresql.JSON module.
--   
--   (here:
--   https://hackage.haskell.org/package/persistent-postgresql-2.10.0/docs/Database-Persist-Postgresql-JSON.html)
--   
--   
PostgreSQL Documentation
--   
--   
--       | Type   | Description                                            |  Example
--   ----+--------+--------------------------------------------------------+----------------------------------------
--    ?& | text[] | Do all of these array strings exist as top-level keys? | '["a", "b"]'::jsonb ?& array[a, b]
--   
(?&.) :: JSONBExpr a -> [Text] -> SqlExpr (Value Bool)
infixl 6 ?&.

-- | Requires PostgreSQL version >= 9.5
--   
--   This operator can remove a key from an object or a string element from
--   an array when using text, and remove certain elements by index from an
--   array when using integers.
--   
--   Negative integers delete counting from the end of the array. (e.g.
--   -1 being the last element, -2 being the second to
--   last, etc.)
--   
--   CAUTION: THIS FUNCTION THROWS AN EXCEPTION WHEN USED ON ANYTHING
--   OTHER THAN OBJECTS OR ARRAYS WHEN USING TEXT, AND ANYTHING
--   OTHER THAN ARRAYS WHEN USING INTEGERS!
--   
--   
Objects and arrays
--   
--   
--   {"a": 3.14}            - "a"         == {}
--   {"a": "b"}             - "b"         == {"a": "b"}
--   {"a": 3.14}            - "a"         == {}
--   {"a": 3.14, "c": true} - "a"         == {"c": true}
--   ["a", 2, "c"]          - "a"         == [2, "c"] -- can remove strings from arrays
--   [true, "b", 5]         - 0           == ["b", 5]
--   [true, "b", 5]         - 3           == [true, "b", 5]
--   [true, "b", 5]         - -1          == [true, "b"]
--   [true, "b", 5]         - -4          == [true, "b", 5]
--   []                     - 1           == []
--   {"1": true}            - 1           == ERROR: cannot delete from object using integer index
--   1                      - <anything>  == ERROR: cannot delete from scalar
--   "a"                    - <anything>  == ERROR: cannot delete from scalar
--   true                   - <anything>  == ERROR: cannot delete from scalar
--   null                   - <anything>  == ERROR: cannot delete from scalar
--   
--   
--   
PostgreSQL Documentation
--   
--   
--      | Type    | Description                                                            |  Example
--   ---+---------+------------------------------------------------------------------------+-------------------------------------------------
--    - | text    | Delete key/value pair or string element from left operand.             | '{"a": "b"}'::jsonb - a
--      |         | Key/value pairs are matched based on their key value.                  |
--    - | integer | Delete the array element with specified index (Negative integers count | '["a", "b"]'::jsonb - 1
--      |         | from the end). Throws an error if top level container is not an array. |
--   
(-.) :: JSONBExpr a -> JSONAccessor -> JSONBExpr b
infixl 6 -.

-- | Requires PostgreSQL version >= 10
--   
--   Removes a set of keys from an object, or string elements from an
--   array.
--   
--   This is the same operator internally as -., but the option to
--   use a text array, instead of text or
--   integer was only added in version 10. That's why this
--   function is seperate from -.
--   
--   NOTE: The following is equivalent:
--   
--   
--   {some JSON expression} -. "a" -. "b"
--   
--   
--   is equivalent to
--   
--   
--   {some JSON expression} --. ["a","b"]
--   
--   
--   
PostgreSQL Documentation
--   
--   
--      | Type    | Description                                                            |  Example
--   ---+---------+------------------------------------------------------------------------+-------------------------------------------------
--    - | text[]  | Delete multiple key/value pairs or string elements from left operand.  | '{"a": "b", "c": "d"}'::jsonb - '{a,c}'::text[]
--      |         | Key/value pairs are matched based on their key value.                  |
--   
(--.) :: JSONBExpr a -> [Text] -> JSONBExpr b
infixl 6 --.

-- | Requires PostgreSQL version >= 9.5
--   
--   This operator can remove elements nested in an object.
--   
--   If a Text is not parsable as a number when selecting in an
--   array (even when halfway through the selection) an exception will be
--   thrown.
--   
--   Negative integers delete counting from the end of an array. (e.g.
--   -1 being the last element, -2 being the second to
--   last, etc.)
--   
--   CAUTION: THIS FUNCTION THROWS AN EXCEPTION WHEN USED ON
--   ANYTHING OTHER THAN OBJECTS OR ARRAYS, AND WILL ALSO THROW WHEN
--   TRYING TO SELECT AN ARRAY ELEMENT WITH A NON-INTEGER TEXT
--   
--   
Objects
--   
--   
--   {"a": 3.14, "b": null}        #- []        == {"a": 3.14, "b": null}
--   {"a": 3.14, "b": null}        #- ["a"]     == {"b": null}
--   {"a": 3.14, "b": null}        #- ["a","b"] == {"a": 3.14, "b": null}
--   {"a": {"b":false}, "b": null} #- ["a","b"] == {"a": {}, "b": null}
--   
--   
--   
Arrays
--   
--   
--   [true, {"b":null}, 5]       #- []            == [true, {"b":null}, 5]
--   [true, {"b":null}, 5]       #- ["0"]         == [{"b":null}, 5]
--   [true, {"b":null}, 5]       #- ["b"]         == ERROR: path element at position 1 is not an integer: "b"
--   [true, {"b":null}, 5]       #- ["1","b"]     == [true, {}, 5]
--   [true, {"b":null}, 5]       #- ["-2","b"]    == [true, {}, 5]
--   {"a": {"b":[false,4,null]}} #- ["a","b","2"] == {"a": {"b":[false,4]}}
--   {"a": {"b":[false,4,null]}} #- ["a","b","c"] == ERROR: path element at position 3 is not an integer: "c"
--   
--   
--   
Other values
--   
--   
--   1    #- {anything} == ERROR: cannot delete from scalar
--   "a"  #- {anything} == ERROR: cannot delete from scalar
--   true #- {anything} == ERROR: cannot delete from scalar
--   null #- {anything} == ERROR: cannot delete from scalar
--   
--   
--   
PostgreSQL Documentation
--   
--   
--       | Type   | Description                                             |  Example
--   ----+--------+---------------------------------------------------------+------------------------------------
--    #- | text[] | Delete the field or element with specified path         | '["a", {"b":1}]'::jsonb #- '{1,b}'
--       |        | (for JSON arrays, negative integers count from the end) |
--   
(#-.) :: JSONBExpr a -> [Text] -> JSONBExpr b
infixl 6 #-.

-- | Requires PostgreSQL version >= 9.5
--   
--   This operator concatenates two JSON values. The behaviour is
--   self-evident when used on two arrays, but the behaviour on different
--   combinations of JSON values might behave unexpectedly.
--   
--   CAUTION: THIS FUNCTION THROWS AN EXCEPTION WHEN CONCATENATING
--   A JSON OBJECT WITH A JSON SCALAR VALUE!
--   
--   
Arrays
--   
--   This operator is a standard concatenation function when used on
--   arrays:
--   
--   
--   [1,2]   || [2,3]   == [1,2,2,3]
--   []      || [1,2,3] == [1,2,3]
--   [1,2,3] || []      == [1,2,3]
--   
--   
--   
Objects
--   
--   When concatenating JSON objects with other JSON objects, the fields
--   from the JSON object on the right are added to the JSON object on the
--   left. When concatenating a JSON object with a JSON array, the object
--   will be inserted into the array; either on the left or right,
--   depending on the position relative to the operator.
--   
--   When concatening an object with a scalar value, an exception is
--   thrown.
--   
--   
--   {"a": 3.14}                    || {"b": true}         == {"a": 3.14, "b": true}
--   {"a": "b"}                     || {"a": null}         == {"a": null}
--   {"a": {"b": true, "c": false}} || {"a": {"b": false}} == {"a": {"b": false}}
--   {"a": 3.14}                    || [1,null]            == [{"a": 3.14},1,null]
--   [1,null]                       || {"a": 3.14}         == [1,null,{"a": 3.14}]
--   1                              || {"a": 3.14}         == ERROR: invalid concatenation of jsonb objects
--   {"a": 3.14}                    || false               == ERROR: invalid concatenation of jsonb objects
--   
--   
--   
Scalar values
--   
--   Scalar values can be thought of as being singleton arrays when used
--   with this operator. This rule does not apply when concatenating with
--   JSON objects.
--   
--   
--   1          || null       == [1,null]
--   true       || "a"        == [true,"a"]
--   [1,2]      || false      == [1,2,false]
--   null       || [1,"a"]    == [null,1,"a"]
--   {"a":3.14} || true       == ERROR: invalid concatenation of jsonb objects
--   3.14       || {"a":3.14} == ERROR: invalid concatenation of jsonb objects
--   {"a":3.14} || [true]     == [{"a":3.14},true]
--   [false]    || {"a":3.14} == [false,{"a":3.14}]
--   
--   
--   
PostgreSQL Documentation
--   
--   
--       | Type  | Description                                         |  Example
--   ----+-------+-----------------------------------------------------+--------------------------------------------
--    || | jsonb | Concatenate two jsonb values into a new jsonb value | '["a", "b"]'::jsonb || '["c", "d"]'::jsonb
--   
--   
--   Note: The || operator concatenates the elements at the top
--   level of each of its operands. It does not operate
--   recursively.
--   
--   For example, if both operands are objects with a common key field
--   name, the value of the field in the result will just be the
--   value from the right hand operand.
(||.) :: JSONBExpr a -> JSONBExpr b -> JSONBExpr c
infixl 6 ||.

module Database.Esqueleto.Record

-- | Takes the name of a Haskell record type and creates a variant of that
--   record prefixed with Sql which can be used in esqueleto
--   expressions. This reduces the amount of pattern matching on large
--   tuples required to interact with data extracted with esqueleto.
--   
--   Note that because the input record and the Sql-prefixed
--   record share field names, the {-# LANGUAGE DuplicateRecordFields
--   #-} extension is required in modules that use
--   deriveEsqueletoRecord. Additionally, the {-# LANGUAGE
--   TypeApplications #-} extension is required for some of the
--   generated code.
--   
--   Given the following record:
--   
--   
--   data MyRecord = MyRecord
--     { myName    :: Text
--     , myAge     :: Maybe Int
--     , myUser    :: Entity User
--     , myAddress :: Maybe (Entity Address)
--     }
--   
--   
--   $(deriveEsqueletoRecord ''MyRecord) will generate
--   roughly the following code:
--   
--   
--   data SqlMyRecord =
--     SqlMyRecord { myName    :: SqlExpr (Value Text)
--                 , myAge     :: SqlExpr (Value (Maybe Int))
--                 , myUser    :: SqlExpr (Entity User)
--                 , myAddress :: SqlExpr (Maybe (Entity Address))
--                 }
--   
--   instance SqlSelect SqlMyRecord MyRecord where
--     sqlSelectCols
--       identInfo
--       SqlMyRecord { myName    = myName
--                   , myAge     = myAge
--                   , myUser    = myUser
--                   , myAddress = myAddress
--                   } =
--       sqlSelectCols identInfo (myName :& myAge :& myUser :& myAddress)
--   
--     sqlSelectColCount _ =
--       sqlSelectColCount
--         (Proxy @(   (SqlExpr (Value Text))
--                  :& (SqlExpr (Value (Maybe Int)))
--                  :& (SqlExpr (Entity User))
--                  :& (SqlExpr (Maybe (Entity Address)))))
--   
--     sqlSelectProcessRow columns =
--       first ((fromString "Failed to parse MyRecord: ") <>)
--             (evalStateT process columns)
--       where
--         process = do
--           Value myName <- takeColumns @(SqlExpr (Value Text))
--           Value myAge  <- takeColumns @(SqlExpr (Value (Maybe Int)))
--           myUser       <- takeColumns @(SqlExpr (Entity User))
--           myAddress    <- takeColumns @(SqlExpr (Maybe (Entity Address)))
--           pure MyRecord { myName = myName
--                         , myAge = myAge
--                         , myUser = myUser
--                         , myAddress = myAddress
--                         }
--   
--   
--   Then, we could write a selection function to use the record in
--   queries:
--   
--   
--   getMyRecord :: SqlPersistT IO [MyRecord]
--   getMyRecord = select myRecordQuery
--   
--   myRecordQuery :: SqlQuery SqlMyRecord
--   myRecordQuery = do
--     user :& address <- from $
--       table @User
--         `<a>leftJoin</a>`
--         table @Address
--         `<a>on</a>` (do \(user :& address) -> user ^. #address ==. address ?. #id)
--     pure
--       SqlMyRecord
--         { myName = castString $ user ^. #firstName
--         , myAge = val 10
--         , myUser = user
--         , myAddress = address
--         }
--   
deriveEsqueletoRecord :: Name -> Q [Dec]

-- | Takes the name of a Haskell record type and creates a variant of that
--   record based on the supplied settings which can be used in esqueleto
--   expressions. This reduces the amount of pattern matching on large
--   tuples required to interact with data extracted with esqueleto.
--   
--   This is a variant of deriveEsqueletoRecord which allows you to
--   avoid the use of {-# LANGUAGE DuplicateRecordFields #-}, by
--   configuring the DeriveEsqueletoRecordSettings used to generate
--   the SQL record.
deriveEsqueletoRecordWith :: DeriveEsqueletoRecordSettings -> Name -> Q [Dec]

-- | Codegen settings for deriveEsqueletoRecordWith.
data DeriveEsqueletoRecordSettings
DeriveEsqueletoRecordSettings :: (String -> String) -> (String -> String) -> (String -> String) -> (String -> String) -> DeriveEsqueletoRecordSettings

-- | Function applied to the Haskell record's type name and constructor
--   name to produce the SQL record's type name and constructor name.
[sqlNameModifier] :: DeriveEsqueletoRecordSettings -> String -> String

-- | Function applied to the Haskell record's type name and constructor
--   name to produce the ToMaybe record's type name and constructor
--   name.
[sqlMaybeNameModifier] :: DeriveEsqueletoRecordSettings -> String -> String

-- | Function applied to the Haskell record's field names to produce the
--   SQL record's field names.
[sqlFieldModifier] :: DeriveEsqueletoRecordSettings -> String -> String

-- | Function applied to the Haskell record's field names to produce the
--   ToMaybe SQL record's field names.
[sqlMaybeFieldModifier] :: DeriveEsqueletoRecordSettings -> String -> String

-- | The default codegen settings for deriveEsqueletoRecord.
--   
--   These defaults will cause you to require {-# LANGUAGE
--   DuplicateRecordFields #-} in certain cases (see
--   deriveEsqueletoRecord.) If you don't want to do this, change
--   the value of sqlFieldModifier so the field names of the
--   generated SQL record different from those of the Haskell record.
defaultDeriveEsqueletoRecordSettings :: DeriveEsqueletoRecordSettings

-- | Statefully parse some number of columns from a list of
--   PersistValues, where the number of columns to parse is
--   determined by sqlSelectColCount for a.
--   
--   This is used to implement sqlSelectProcessRow for records
--   created with deriveEsqueletoRecord.
takeColumns :: SqlSelect a b => StateT [PersistValue] (Either Text) b

-- | Statefully parse some number of columns from a list of
--   PersistValues, where the number of columns to parse is
--   determined by sqlSelectColCount for a.
--   
--   This is used to implement sqlSelectProcessRow for records
--   created with deriveEsqueletoRecord.
takeMaybeColumns :: SqlSelect a (ToMaybeT b) => StateT [PersistValue] (Either Text) (ToMaybeT b)

-- | This module contain SQLite-specific functions.
module Database.Esqueleto.SQLite

-- | (random()) Split out into database specific modules because
--   MySQL uses `rand()`.
--   
--   Since: 2.6.0
random_ :: (PersistField a, Num a) => SqlExpr (Value a)
