module Mensam.Server.Database.Extra where

import Mensam.API.Order

import Control.Monad.Catch
import Data.Kind
import Data.Maybe
import Data.Proxy
import Data.Text qualified as T
import Data.Typeable
import Database.Selda
import GHC.TypeLits

-- | Run 'query', but throw an error when there are multiple results.
queryUnique :: (MonadSelda m, MonadThrow m, Result a) => Query (Backend m) a -> m (Maybe (Res a))
queryUnique :: forall (m :: * -> *) a.
(MonadSelda m, MonadThrow m, Result a) =>
Query (Backend m) a -> m (Maybe (Res a))
queryUnique Query (Backend m) a
q =
  Query (Backend m) a -> m [Res a]
forall (m :: * -> *) a.
(MonadSelda m, Result a) =>
Query (Backend m) a -> m [Res a]
query Query (Backend m) a
q m [Res a] -> ([Res a] -> m (Maybe (Res a))) -> m (Maybe (Res a))
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Res a
_ : Res a
_ : [Res a]
_ -> SqlErrorMensamNotUniqueQuery -> m (Maybe (Res a))
forall e a. (HasCallStack, Exception e) => e -> m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM SqlErrorMensamNotUniqueQuery
MkSqlErrorMensamNotUniqueQuery
    [Res a
result] -> Maybe (Res a) -> m (Maybe (Res a))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (Res a) -> m (Maybe (Res a)))
-> Maybe (Res a) -> m (Maybe (Res a))
forall a b. (a -> b) -> a -> b
$ Res a -> Maybe (Res a)
forall a. a -> Maybe a
Just Res a
result
    [] -> Maybe (Res a) -> m (Maybe (Res a))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Res a)
forall a. Maybe a
Nothing

-- | Expected unique result, but the query returned multiple results.
type SqlErrorMensamNotUniqueQuery :: Type
data SqlErrorMensamNotUniqueQuery = MkSqlErrorMensamNotUniqueQuery
  deriving stock (SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> Bool
(SqlErrorMensamNotUniqueQuery
 -> SqlErrorMensamNotUniqueQuery -> Bool)
-> (SqlErrorMensamNotUniqueQuery
    -> SqlErrorMensamNotUniqueQuery -> Bool)
-> Eq SqlErrorMensamNotUniqueQuery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> Bool
== :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> Bool
$c/= :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> Bool
/= :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> Bool
Eq, (forall x.
 SqlErrorMensamNotUniqueQuery -> Rep SqlErrorMensamNotUniqueQuery x)
-> (forall x.
    Rep SqlErrorMensamNotUniqueQuery x -> SqlErrorMensamNotUniqueQuery)
-> Generic SqlErrorMensamNotUniqueQuery
forall x.
Rep SqlErrorMensamNotUniqueQuery x -> SqlErrorMensamNotUniqueQuery
forall x.
SqlErrorMensamNotUniqueQuery -> Rep SqlErrorMensamNotUniqueQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
SqlErrorMensamNotUniqueQuery -> Rep SqlErrorMensamNotUniqueQuery x
from :: forall x.
SqlErrorMensamNotUniqueQuery -> Rep SqlErrorMensamNotUniqueQuery x
$cto :: forall x.
Rep SqlErrorMensamNotUniqueQuery x -> SqlErrorMensamNotUniqueQuery
to :: forall x.
Rep SqlErrorMensamNotUniqueQuery x -> SqlErrorMensamNotUniqueQuery
Generic, Eq SqlErrorMensamNotUniqueQuery
Eq SqlErrorMensamNotUniqueQuery =>
(SqlErrorMensamNotUniqueQuery
 -> SqlErrorMensamNotUniqueQuery -> Ordering)
-> (SqlErrorMensamNotUniqueQuery
    -> SqlErrorMensamNotUniqueQuery -> Bool)
-> (SqlErrorMensamNotUniqueQuery
    -> SqlErrorMensamNotUniqueQuery -> Bool)
-> (SqlErrorMensamNotUniqueQuery
    -> SqlErrorMensamNotUniqueQuery -> Bool)
-> (SqlErrorMensamNotUniqueQuery
    -> SqlErrorMensamNotUniqueQuery -> Bool)
-> (SqlErrorMensamNotUniqueQuery
    -> SqlErrorMensamNotUniqueQuery -> SqlErrorMensamNotUniqueQuery)
-> (SqlErrorMensamNotUniqueQuery
    -> SqlErrorMensamNotUniqueQuery -> SqlErrorMensamNotUniqueQuery)
-> Ord SqlErrorMensamNotUniqueQuery
SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> Bool
SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> Ordering
SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> SqlErrorMensamNotUniqueQuery
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> Ordering
compare :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> Ordering
$c< :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> Bool
< :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> Bool
$c<= :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> Bool
<= :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> Bool
$c> :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> Bool
> :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> Bool
$c>= :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> Bool
>= :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> Bool
$cmax :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> SqlErrorMensamNotUniqueQuery
max :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> SqlErrorMensamNotUniqueQuery
$cmin :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> SqlErrorMensamNotUniqueQuery
min :: SqlErrorMensamNotUniqueQuery
-> SqlErrorMensamNotUniqueQuery -> SqlErrorMensamNotUniqueQuery
Ord, ReadPrec [SqlErrorMensamNotUniqueQuery]
ReadPrec SqlErrorMensamNotUniqueQuery
Int -> ReadS SqlErrorMensamNotUniqueQuery
ReadS [SqlErrorMensamNotUniqueQuery]
(Int -> ReadS SqlErrorMensamNotUniqueQuery)
-> ReadS [SqlErrorMensamNotUniqueQuery]
-> ReadPrec SqlErrorMensamNotUniqueQuery
-> ReadPrec [SqlErrorMensamNotUniqueQuery]
-> Read SqlErrorMensamNotUniqueQuery
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SqlErrorMensamNotUniqueQuery
readsPrec :: Int -> ReadS SqlErrorMensamNotUniqueQuery
$creadList :: ReadS [SqlErrorMensamNotUniqueQuery]
readList :: ReadS [SqlErrorMensamNotUniqueQuery]
$creadPrec :: ReadPrec SqlErrorMensamNotUniqueQuery
readPrec :: ReadPrec SqlErrorMensamNotUniqueQuery
$creadListPrec :: ReadPrec [SqlErrorMensamNotUniqueQuery]
readListPrec :: ReadPrec [SqlErrorMensamNotUniqueQuery]
Read, Int -> SqlErrorMensamNotUniqueQuery -> ShowS
[SqlErrorMensamNotUniqueQuery] -> ShowS
SqlErrorMensamNotUniqueQuery -> String
(Int -> SqlErrorMensamNotUniqueQuery -> ShowS)
-> (SqlErrorMensamNotUniqueQuery -> String)
-> ([SqlErrorMensamNotUniqueQuery] -> ShowS)
-> Show SqlErrorMensamNotUniqueQuery
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SqlErrorMensamNotUniqueQuery -> ShowS
showsPrec :: Int -> SqlErrorMensamNotUniqueQuery -> ShowS
$cshow :: SqlErrorMensamNotUniqueQuery -> String
show :: SqlErrorMensamNotUniqueQuery -> String
$cshowList :: [SqlErrorMensamNotUniqueQuery] -> ShowS
showList :: [SqlErrorMensamNotUniqueQuery] -> ShowS
Show)
  deriving anyclass (Show SqlErrorMensamNotUniqueQuery
Typeable SqlErrorMensamNotUniqueQuery
(Typeable SqlErrorMensamNotUniqueQuery,
 Show SqlErrorMensamNotUniqueQuery) =>
(SqlErrorMensamNotUniqueQuery -> SomeException)
-> (SomeException -> Maybe SqlErrorMensamNotUniqueQuery)
-> (SqlErrorMensamNotUniqueQuery -> String)
-> Exception SqlErrorMensamNotUniqueQuery
SomeException -> Maybe SqlErrorMensamNotUniqueQuery
SqlErrorMensamNotUniqueQuery -> String
SqlErrorMensamNotUniqueQuery -> SomeException
forall e.
(Typeable e, Show e) =>
(e -> SomeException)
-> (SomeException -> Maybe e) -> (e -> String) -> Exception e
$ctoException :: SqlErrorMensamNotUniqueQuery -> SomeException
toException :: SqlErrorMensamNotUniqueQuery -> SomeException
$cfromException :: SomeException -> Maybe SqlErrorMensamNotUniqueQuery
fromException :: SomeException -> Maybe SqlErrorMensamNotUniqueQuery
$cdisplayException :: SqlErrorMensamNotUniqueQuery -> String
displayException :: SqlErrorMensamNotUniqueQuery -> String
Exception)

-- | Run 'query', but throw an error unless there is exactly one result.
queryOne :: (MonadSelda m, MonadCatch m, Result a) => Query (Backend m) a -> m (Res a)
queryOne :: forall (m :: * -> *) a.
(MonadSelda m, MonadCatch m, Result a) =>
Query (Backend m) a -> m (Res a)
queryOne Query (Backend m) a
q = do
  Maybe (Res a)
queryUniqueResult <- m (Maybe (Res a))
-> (SqlErrorMensamNotUniqueQuery -> m (Maybe (Res a)))
-> m (Maybe (Res a))
forall e a. (HasCallStack, Exception e) => m a -> (e -> m a) -> m a
forall (m :: * -> *) e a.
(MonadCatch m, HasCallStack, Exception e) =>
m a -> (e -> m a) -> m a
catch (Query (Backend m) a -> m (Maybe (Res a))
forall (m :: * -> *) a.
(MonadSelda m, MonadThrow m, Result a) =>
Query (Backend m) a -> m (Maybe (Res a))
queryUnique Query (Backend m) a
q) ((SqlErrorMensamNotUniqueQuery -> m (Maybe (Res a)))
 -> m (Maybe (Res a)))
-> (SqlErrorMensamNotUniqueQuery -> m (Maybe (Res a)))
-> m (Maybe (Res a))
forall a b. (a -> b) -> a -> b
$ \case
    SqlErrorMensamNotUniqueQuery
MkSqlErrorMensamNotUniqueQuery -> SqlErrorMensamNotOneQuery -> m (Maybe (Res a))
forall e a. (HasCallStack, Exception e) => e -> m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM (SqlErrorMensamNotOneQuery -> m (Maybe (Res a)))
-> SqlErrorMensamNotOneQuery -> m (Maybe (Res a))
forall a b. (a -> b) -> a -> b
$ Maybe SqlErrorMensamNotUniqueQuery -> SqlErrorMensamNotOneQuery
MkSqlErrorMensamNotOneQuery (Maybe SqlErrorMensamNotUniqueQuery -> SqlErrorMensamNotOneQuery)
-> Maybe SqlErrorMensamNotUniqueQuery -> SqlErrorMensamNotOneQuery
forall a b. (a -> b) -> a -> b
$ SqlErrorMensamNotUniqueQuery -> Maybe SqlErrorMensamNotUniqueQuery
forall a. a -> Maybe a
Just SqlErrorMensamNotUniqueQuery
MkSqlErrorMensamNotUniqueQuery
  case Maybe (Res a)
queryUniqueResult of
    Just Res a
result -> Res a -> m (Res a)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Res a
result
    Maybe (Res a)
Nothing -> SqlErrorMensamNotOneQuery -> m (Res a)
forall e a. (HasCallStack, Exception e) => e -> m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM (SqlErrorMensamNotOneQuery -> m (Res a))
-> SqlErrorMensamNotOneQuery -> m (Res a)
forall a b. (a -> b) -> a -> b
$ Maybe SqlErrorMensamNotUniqueQuery -> SqlErrorMensamNotOneQuery
MkSqlErrorMensamNotOneQuery Maybe SqlErrorMensamNotUniqueQuery
forall a. Maybe a
Nothing

-- | Expected exactly one result, but the query didn't return a lone result.
type SqlErrorMensamNotOneQuery :: Type
newtype SqlErrorMensamNotOneQuery = MkSqlErrorMensamNotOneQuery (Maybe SqlErrorMensamNotUniqueQuery)
  deriving stock (SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool
(SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool)
-> (SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool)
-> Eq SqlErrorMensamNotOneQuery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool
== :: SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool
$c/= :: SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool
/= :: SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool
Eq, (forall x.
 SqlErrorMensamNotOneQuery -> Rep SqlErrorMensamNotOneQuery x)
-> (forall x.
    Rep SqlErrorMensamNotOneQuery x -> SqlErrorMensamNotOneQuery)
-> Generic SqlErrorMensamNotOneQuery
forall x.
Rep SqlErrorMensamNotOneQuery x -> SqlErrorMensamNotOneQuery
forall x.
SqlErrorMensamNotOneQuery -> Rep SqlErrorMensamNotOneQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
SqlErrorMensamNotOneQuery -> Rep SqlErrorMensamNotOneQuery x
from :: forall x.
SqlErrorMensamNotOneQuery -> Rep SqlErrorMensamNotOneQuery x
$cto :: forall x.
Rep SqlErrorMensamNotOneQuery x -> SqlErrorMensamNotOneQuery
to :: forall x.
Rep SqlErrorMensamNotOneQuery x -> SqlErrorMensamNotOneQuery
Generic, Eq SqlErrorMensamNotOneQuery
Eq SqlErrorMensamNotOneQuery =>
(SqlErrorMensamNotOneQuery
 -> SqlErrorMensamNotOneQuery -> Ordering)
-> (SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool)
-> (SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool)
-> (SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool)
-> (SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool)
-> (SqlErrorMensamNotOneQuery
    -> SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery)
-> (SqlErrorMensamNotOneQuery
    -> SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery)
-> Ord SqlErrorMensamNotOneQuery
SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool
SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Ordering
SqlErrorMensamNotOneQuery
-> SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Ordering
compare :: SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Ordering
$c< :: SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool
< :: SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool
$c<= :: SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool
<= :: SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool
$c> :: SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool
> :: SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool
$c>= :: SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool
>= :: SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery -> Bool
$cmax :: SqlErrorMensamNotOneQuery
-> SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery
max :: SqlErrorMensamNotOneQuery
-> SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery
$cmin :: SqlErrorMensamNotOneQuery
-> SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery
min :: SqlErrorMensamNotOneQuery
-> SqlErrorMensamNotOneQuery -> SqlErrorMensamNotOneQuery
Ord, ReadPrec [SqlErrorMensamNotOneQuery]
ReadPrec SqlErrorMensamNotOneQuery
Int -> ReadS SqlErrorMensamNotOneQuery
ReadS [SqlErrorMensamNotOneQuery]
(Int -> ReadS SqlErrorMensamNotOneQuery)
-> ReadS [SqlErrorMensamNotOneQuery]
-> ReadPrec SqlErrorMensamNotOneQuery
-> ReadPrec [SqlErrorMensamNotOneQuery]
-> Read SqlErrorMensamNotOneQuery
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SqlErrorMensamNotOneQuery
readsPrec :: Int -> ReadS SqlErrorMensamNotOneQuery
$creadList :: ReadS [SqlErrorMensamNotOneQuery]
readList :: ReadS [SqlErrorMensamNotOneQuery]
$creadPrec :: ReadPrec SqlErrorMensamNotOneQuery
readPrec :: ReadPrec SqlErrorMensamNotOneQuery
$creadListPrec :: ReadPrec [SqlErrorMensamNotOneQuery]
readListPrec :: ReadPrec [SqlErrorMensamNotOneQuery]
Read, Int -> SqlErrorMensamNotOneQuery -> ShowS
[SqlErrorMensamNotOneQuery] -> ShowS
SqlErrorMensamNotOneQuery -> String
(Int -> SqlErrorMensamNotOneQuery -> ShowS)
-> (SqlErrorMensamNotOneQuery -> String)
-> ([SqlErrorMensamNotOneQuery] -> ShowS)
-> Show SqlErrorMensamNotOneQuery
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SqlErrorMensamNotOneQuery -> ShowS
showsPrec :: Int -> SqlErrorMensamNotOneQuery -> ShowS
$cshow :: SqlErrorMensamNotOneQuery -> String
show :: SqlErrorMensamNotOneQuery -> String
$cshowList :: [SqlErrorMensamNotOneQuery] -> ShowS
showList :: [SqlErrorMensamNotOneQuery] -> ShowS
Show)
  deriving anyclass (Show SqlErrorMensamNotOneQuery
Typeable SqlErrorMensamNotOneQuery
(Typeable SqlErrorMensamNotOneQuery,
 Show SqlErrorMensamNotOneQuery) =>
(SqlErrorMensamNotOneQuery -> SomeException)
-> (SomeException -> Maybe SqlErrorMensamNotOneQuery)
-> (SqlErrorMensamNotOneQuery -> String)
-> Exception SqlErrorMensamNotOneQuery
SomeException -> Maybe SqlErrorMensamNotOneQuery
SqlErrorMensamNotOneQuery -> String
SqlErrorMensamNotOneQuery -> SomeException
forall e.
(Typeable e, Show e) =>
(e -> SomeException)
-> (SomeException -> Maybe e) -> (e -> String) -> Exception e
$ctoException :: SqlErrorMensamNotOneQuery -> SomeException
toException :: SqlErrorMensamNotOneQuery -> SomeException
$cfromException :: SomeException -> Maybe SqlErrorMensamNotOneQuery
fromException :: SomeException -> Maybe SqlErrorMensamNotOneQuery
$cdisplayException :: SqlErrorMensamNotOneQuery -> String
displayException :: SqlErrorMensamNotOneQuery -> String
Exception)

-- | Run 'insert', but throw an error unless exactly one row is being inserted.
insertOne :: (MonadSelda m, MonadThrow m, Relational a) => Table a -> a -> m ()
insertOne :: forall (m :: * -> *) a.
(MonadSelda m, MonadThrow m, Relational a) =>
Table a -> a -> m ()
insertOne Table a
t a
a =
  Table a -> [a] -> m Int
forall (m :: * -> *) a.
(MonadSelda m, Relational a) =>
Table a -> [a] -> m Int
insert Table a
t [a
a] m Int -> (Int -> m ()) -> m ()
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Int
1 -> () -> m ()
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
    Int
0 -> SeldaError -> m ()
forall e a. (HasCallStack, Exception e) => e -> m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM (SeldaError -> m ()) -> SeldaError -> m ()
forall a b. (a -> b) -> a -> b
$ String -> SeldaError
UnsafeError String
"Tried to insert exactly one row, but no rows have been inserted at all."
    Int
n -> SeldaError -> m ()
forall e a. (HasCallStack, Exception e) => e -> m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM (SeldaError -> m ()) -> SeldaError -> m ()
forall a b. (a -> b) -> a -> b
$ String -> SeldaError
UnsafeError (String -> SeldaError) -> String -> SeldaError
forall a b. (a -> b) -> a -> b
$ String
"Tried to insert exactly one row, but multiple rows have been inserted: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Int -> String
forall a. Show a => a -> String
show Int
n

-- | Run 'deleteFrom', but throw an error when multiple rows have been deleted.
deleteUniqueFrom :: (MonadSelda m, MonadThrow m, Relational a) => Table a -> (Row (Backend m) a -> Col (Backend m) Bool) -> m Bool
deleteUniqueFrom :: forall (m :: * -> *) a.
(MonadSelda m, MonadThrow m, Relational a) =>
Table a -> (Row (Backend m) a -> Col (Backend m) Bool) -> m Bool
deleteUniqueFrom Table a
t Row (Backend m) a -> Col (Backend m) Bool
f = do
  Table a -> (Row (Backend m) a -> Col (Backend m) Bool) -> m Int
forall (m :: * -> *) a.
(MonadSelda m, Relational a) =>
Table a -> (Row (Backend m) a -> Col (Backend m) Bool) -> m Int
deleteFrom Table a
t Row (Backend m) a -> Col (Backend m) Bool
f m Int -> (Int -> m Bool) -> m Bool
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Int
1 -> Bool -> m Bool
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True
    Int
0 -> Bool -> m Bool
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False
    Int
n -> SeldaError -> m Bool
forall e a. (HasCallStack, Exception e) => e -> m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM (SeldaError -> m Bool) -> SeldaError -> m Bool
forall a b. (a -> b) -> a -> b
$ String -> SeldaError
UnsafeError (String -> SeldaError) -> String -> SeldaError
forall a b. (a -> b) -> a -> b
$ String
"Expected to delete unique row, but the constraint matches multiple rows: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Int -> String
forall a. Show a => a -> String
show Int
n

-- | Run 'deleteFrom', but throw an error unless exactly one row has been deleted.
deleteOneFrom :: (MonadSelda m, MonadThrow m, Relational a) => Table a -> (Row (Backend m) a -> Col (Backend m) Bool) -> m ()
deleteOneFrom :: forall (m :: * -> *) a.
(MonadSelda m, MonadThrow m, Relational a) =>
Table a -> (Row (Backend m) a -> Col (Backend m) Bool) -> m ()
deleteOneFrom Table a
t Row (Backend m) a -> Col (Backend m) Bool
f = do
  Table a -> (Row (Backend m) a -> Col (Backend m) Bool) -> m Bool
forall (m :: * -> *) a.
(MonadSelda m, MonadThrow m, Relational a) =>
Table a -> (Row (Backend m) a -> Col (Backend m) Bool) -> m Bool
deleteUniqueFrom Table a
t Row (Backend m) a -> Col (Backend m) Bool
f m Bool -> (Bool -> m ()) -> m ()
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Bool
True -> () -> m ()
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
    Bool
False -> SeldaError -> m ()
forall e a. (HasCallStack, Exception e) => e -> m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM (SeldaError -> m ()) -> SeldaError -> m ()
forall a b. (a -> b) -> a -> b
$ String -> SeldaError
UnsafeError String
"Expected to delete exactly one row, but the constraint didn't match any rows."

-- | Run 'update', but throw an error when multiple rows are affected.
updateUnique :: (MonadSelda m, MonadThrow m, Relational a) => Table a -> (Row (Backend m) a -> Col (Backend m) Bool) -> (Row (Backend m) a -> Row (Backend m) a) -> m ()
updateUnique :: forall (m :: * -> *) a.
(MonadSelda m, MonadThrow m, Relational a) =>
Table a
-> (Row (Backend m) a -> Col (Backend m) Bool)
-> (Row (Backend m) a -> Row (Backend m) a)
-> m ()
updateUnique Table a
t Row (Backend m) a -> Col (Backend m) Bool
p Row (Backend m) a -> Row (Backend m) a
u =
  Table a
-> (Row (Backend m) a -> Col (Backend m) Bool)
-> (Row (Backend m) a -> Row (Backend m) a)
-> m Int
forall (m :: * -> *) a.
(MonadSelda m, Relational a) =>
Table a
-> (Row (Backend m) a -> Col (Backend m) Bool)
-> (Row (Backend m) a -> Row (Backend m) a)
-> m Int
update Table a
t Row (Backend m) a -> Col (Backend m) Bool
p Row (Backend m) a -> Row (Backend m) a
u m Int -> (Int -> m ()) -> m ()
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Int
0 -> () -> m ()
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
    Int
1 -> () -> m ()
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
    Int
_ -> SqlErrorMensamNotUniqueUpdate -> m ()
forall e a. (HasCallStack, Exception e) => e -> m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM SqlErrorMensamNotUniqueUpdate
MkSqlErrorMensamNotUniqueUpdate

-- | Expected to update a single row, but the update matched multiple rows.
type SqlErrorMensamNotUniqueUpdate :: Type
data SqlErrorMensamNotUniqueUpdate = MkSqlErrorMensamNotUniqueUpdate
  deriving stock (SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> Bool
(SqlErrorMensamNotUniqueUpdate
 -> SqlErrorMensamNotUniqueUpdate -> Bool)
-> (SqlErrorMensamNotUniqueUpdate
    -> SqlErrorMensamNotUniqueUpdate -> Bool)
-> Eq SqlErrorMensamNotUniqueUpdate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> Bool
== :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> Bool
$c/= :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> Bool
/= :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> Bool
Eq, (forall x.
 SqlErrorMensamNotUniqueUpdate
 -> Rep SqlErrorMensamNotUniqueUpdate x)
-> (forall x.
    Rep SqlErrorMensamNotUniqueUpdate x
    -> SqlErrorMensamNotUniqueUpdate)
-> Generic SqlErrorMensamNotUniqueUpdate
forall x.
Rep SqlErrorMensamNotUniqueUpdate x
-> SqlErrorMensamNotUniqueUpdate
forall x.
SqlErrorMensamNotUniqueUpdate
-> Rep SqlErrorMensamNotUniqueUpdate x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
SqlErrorMensamNotUniqueUpdate
-> Rep SqlErrorMensamNotUniqueUpdate x
from :: forall x.
SqlErrorMensamNotUniqueUpdate
-> Rep SqlErrorMensamNotUniqueUpdate x
$cto :: forall x.
Rep SqlErrorMensamNotUniqueUpdate x
-> SqlErrorMensamNotUniqueUpdate
to :: forall x.
Rep SqlErrorMensamNotUniqueUpdate x
-> SqlErrorMensamNotUniqueUpdate
Generic, Eq SqlErrorMensamNotUniqueUpdate
Eq SqlErrorMensamNotUniqueUpdate =>
(SqlErrorMensamNotUniqueUpdate
 -> SqlErrorMensamNotUniqueUpdate -> Ordering)
-> (SqlErrorMensamNotUniqueUpdate
    -> SqlErrorMensamNotUniqueUpdate -> Bool)
-> (SqlErrorMensamNotUniqueUpdate
    -> SqlErrorMensamNotUniqueUpdate -> Bool)
-> (SqlErrorMensamNotUniqueUpdate
    -> SqlErrorMensamNotUniqueUpdate -> Bool)
-> (SqlErrorMensamNotUniqueUpdate
    -> SqlErrorMensamNotUniqueUpdate -> Bool)
-> (SqlErrorMensamNotUniqueUpdate
    -> SqlErrorMensamNotUniqueUpdate -> SqlErrorMensamNotUniqueUpdate)
-> (SqlErrorMensamNotUniqueUpdate
    -> SqlErrorMensamNotUniqueUpdate -> SqlErrorMensamNotUniqueUpdate)
-> Ord SqlErrorMensamNotUniqueUpdate
SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> Bool
SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> Ordering
SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> SqlErrorMensamNotUniqueUpdate
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> Ordering
compare :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> Ordering
$c< :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> Bool
< :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> Bool
$c<= :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> Bool
<= :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> Bool
$c> :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> Bool
> :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> Bool
$c>= :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> Bool
>= :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> Bool
$cmax :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> SqlErrorMensamNotUniqueUpdate
max :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> SqlErrorMensamNotUniqueUpdate
$cmin :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> SqlErrorMensamNotUniqueUpdate
min :: SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotUniqueUpdate -> SqlErrorMensamNotUniqueUpdate
Ord, ReadPrec [SqlErrorMensamNotUniqueUpdate]
ReadPrec SqlErrorMensamNotUniqueUpdate
Int -> ReadS SqlErrorMensamNotUniqueUpdate
ReadS [SqlErrorMensamNotUniqueUpdate]
(Int -> ReadS SqlErrorMensamNotUniqueUpdate)
-> ReadS [SqlErrorMensamNotUniqueUpdate]
-> ReadPrec SqlErrorMensamNotUniqueUpdate
-> ReadPrec [SqlErrorMensamNotUniqueUpdate]
-> Read SqlErrorMensamNotUniqueUpdate
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SqlErrorMensamNotUniqueUpdate
readsPrec :: Int -> ReadS SqlErrorMensamNotUniqueUpdate
$creadList :: ReadS [SqlErrorMensamNotUniqueUpdate]
readList :: ReadS [SqlErrorMensamNotUniqueUpdate]
$creadPrec :: ReadPrec SqlErrorMensamNotUniqueUpdate
readPrec :: ReadPrec SqlErrorMensamNotUniqueUpdate
$creadListPrec :: ReadPrec [SqlErrorMensamNotUniqueUpdate]
readListPrec :: ReadPrec [SqlErrorMensamNotUniqueUpdate]
Read, Int -> SqlErrorMensamNotUniqueUpdate -> ShowS
[SqlErrorMensamNotUniqueUpdate] -> ShowS
SqlErrorMensamNotUniqueUpdate -> String
(Int -> SqlErrorMensamNotUniqueUpdate -> ShowS)
-> (SqlErrorMensamNotUniqueUpdate -> String)
-> ([SqlErrorMensamNotUniqueUpdate] -> ShowS)
-> Show SqlErrorMensamNotUniqueUpdate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SqlErrorMensamNotUniqueUpdate -> ShowS
showsPrec :: Int -> SqlErrorMensamNotUniqueUpdate -> ShowS
$cshow :: SqlErrorMensamNotUniqueUpdate -> String
show :: SqlErrorMensamNotUniqueUpdate -> String
$cshowList :: [SqlErrorMensamNotUniqueUpdate] -> ShowS
showList :: [SqlErrorMensamNotUniqueUpdate] -> ShowS
Show)
  deriving anyclass (Show SqlErrorMensamNotUniqueUpdate
Typeable SqlErrorMensamNotUniqueUpdate
(Typeable SqlErrorMensamNotUniqueUpdate,
 Show SqlErrorMensamNotUniqueUpdate) =>
(SqlErrorMensamNotUniqueUpdate -> SomeException)
-> (SomeException -> Maybe SqlErrorMensamNotUniqueUpdate)
-> (SqlErrorMensamNotUniqueUpdate -> String)
-> Exception SqlErrorMensamNotUniqueUpdate
SomeException -> Maybe SqlErrorMensamNotUniqueUpdate
SqlErrorMensamNotUniqueUpdate -> String
SqlErrorMensamNotUniqueUpdate -> SomeException
forall e.
(Typeable e, Show e) =>
(e -> SomeException)
-> (SomeException -> Maybe e) -> (e -> String) -> Exception e
$ctoException :: SqlErrorMensamNotUniqueUpdate -> SomeException
toException :: SqlErrorMensamNotUniqueUpdate -> SomeException
$cfromException :: SomeException -> Maybe SqlErrorMensamNotUniqueUpdate
fromException :: SomeException -> Maybe SqlErrorMensamNotUniqueUpdate
$cdisplayException :: SqlErrorMensamNotUniqueUpdate -> String
displayException :: SqlErrorMensamNotUniqueUpdate -> String
Exception)

-- | Run 'update', but throw an error unless exactly one row is affected.
updateOne :: (MonadSelda m, MonadThrow m, Relational a) => Table a -> (Row (Backend m) a -> Col (Backend m) Bool) -> (Row (Backend m) a -> Row (Backend m) a) -> m ()
updateOne :: forall (m :: * -> *) a.
(MonadSelda m, MonadThrow m, Relational a) =>
Table a
-> (Row (Backend m) a -> Col (Backend m) Bool)
-> (Row (Backend m) a -> Row (Backend m) a)
-> m ()
updateOne Table a
t Row (Backend m) a -> Col (Backend m) Bool
p Row (Backend m) a -> Row (Backend m) a
u = do
  Table a
-> (Row (Backend m) a -> Col (Backend m) Bool)
-> (Row (Backend m) a -> Row (Backend m) a)
-> m Int
forall (m :: * -> *) a.
(MonadSelda m, Relational a) =>
Table a
-> (Row (Backend m) a -> Col (Backend m) Bool)
-> (Row (Backend m) a -> Row (Backend m) a)
-> m Int
update Table a
t Row (Backend m) a -> Col (Backend m) Bool
p Row (Backend m) a -> Row (Backend m) a
u m Int -> (Int -> m ()) -> m ()
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Int
0 -> SqlErrorMensamNotOneUpdate -> m ()
forall e a. (HasCallStack, Exception e) => e -> m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM (SqlErrorMensamNotOneUpdate -> m ())
-> SqlErrorMensamNotOneUpdate -> m ()
forall a b. (a -> b) -> a -> b
$ Maybe SqlErrorMensamNotUniqueUpdate -> SqlErrorMensamNotOneUpdate
MkSqlErrorMensamNotOneUpdate Maybe SqlErrorMensamNotUniqueUpdate
forall a. Maybe a
Nothing
    Int
1 -> () -> m ()
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
    Int
_ -> SqlErrorMensamNotOneUpdate -> m ()
forall e a. (HasCallStack, Exception e) => e -> m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM (SqlErrorMensamNotOneUpdate -> m ())
-> SqlErrorMensamNotOneUpdate -> m ()
forall a b. (a -> b) -> a -> b
$ Maybe SqlErrorMensamNotUniqueUpdate -> SqlErrorMensamNotOneUpdate
MkSqlErrorMensamNotOneUpdate (Maybe SqlErrorMensamNotUniqueUpdate -> SqlErrorMensamNotOneUpdate)
-> Maybe SqlErrorMensamNotUniqueUpdate
-> SqlErrorMensamNotOneUpdate
forall a b. (a -> b) -> a -> b
$ SqlErrorMensamNotUniqueUpdate
-> Maybe SqlErrorMensamNotUniqueUpdate
forall a. a -> Maybe a
Just SqlErrorMensamNotUniqueUpdate
MkSqlErrorMensamNotUniqueUpdate

-- | Expected to update exactly one row, but the update did not match exactly one row.
type SqlErrorMensamNotOneUpdate :: Type
newtype SqlErrorMensamNotOneUpdate = MkSqlErrorMensamNotOneUpdate (Maybe SqlErrorMensamNotUniqueUpdate)
  deriving stock (SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate -> Bool
(SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate -> Bool)
-> (SqlErrorMensamNotOneUpdate
    -> SqlErrorMensamNotOneUpdate -> Bool)
-> Eq SqlErrorMensamNotOneUpdate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate -> Bool
== :: SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate -> Bool
$c/= :: SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate -> Bool
/= :: SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate -> Bool
Eq, (forall x.
 SqlErrorMensamNotOneUpdate -> Rep SqlErrorMensamNotOneUpdate x)
-> (forall x.
    Rep SqlErrorMensamNotOneUpdate x -> SqlErrorMensamNotOneUpdate)
-> Generic SqlErrorMensamNotOneUpdate
forall x.
Rep SqlErrorMensamNotOneUpdate x -> SqlErrorMensamNotOneUpdate
forall x.
SqlErrorMensamNotOneUpdate -> Rep SqlErrorMensamNotOneUpdate x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
SqlErrorMensamNotOneUpdate -> Rep SqlErrorMensamNotOneUpdate x
from :: forall x.
SqlErrorMensamNotOneUpdate -> Rep SqlErrorMensamNotOneUpdate x
$cto :: forall x.
Rep SqlErrorMensamNotOneUpdate x -> SqlErrorMensamNotOneUpdate
to :: forall x.
Rep SqlErrorMensamNotOneUpdate x -> SqlErrorMensamNotOneUpdate
Generic, Eq SqlErrorMensamNotOneUpdate
Eq SqlErrorMensamNotOneUpdate =>
(SqlErrorMensamNotOneUpdate
 -> SqlErrorMensamNotOneUpdate -> Ordering)
-> (SqlErrorMensamNotOneUpdate
    -> SqlErrorMensamNotOneUpdate -> Bool)
-> (SqlErrorMensamNotOneUpdate
    -> SqlErrorMensamNotOneUpdate -> Bool)
-> (SqlErrorMensamNotOneUpdate
    -> SqlErrorMensamNotOneUpdate -> Bool)
-> (SqlErrorMensamNotOneUpdate
    -> SqlErrorMensamNotOneUpdate -> Bool)
-> (SqlErrorMensamNotOneUpdate
    -> SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate)
-> (SqlErrorMensamNotOneUpdate
    -> SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate)
-> Ord SqlErrorMensamNotOneUpdate
SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate -> Bool
SqlErrorMensamNotOneUpdate
-> SqlErrorMensamNotOneUpdate -> Ordering
SqlErrorMensamNotOneUpdate
-> SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SqlErrorMensamNotOneUpdate
-> SqlErrorMensamNotOneUpdate -> Ordering
compare :: SqlErrorMensamNotOneUpdate
-> SqlErrorMensamNotOneUpdate -> Ordering
$c< :: SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate -> Bool
< :: SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate -> Bool
$c<= :: SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate -> Bool
<= :: SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate -> Bool
$c> :: SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate -> Bool
> :: SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate -> Bool
$c>= :: SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate -> Bool
>= :: SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate -> Bool
$cmax :: SqlErrorMensamNotOneUpdate
-> SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate
max :: SqlErrorMensamNotOneUpdate
-> SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate
$cmin :: SqlErrorMensamNotOneUpdate
-> SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate
min :: SqlErrorMensamNotOneUpdate
-> SqlErrorMensamNotOneUpdate -> SqlErrorMensamNotOneUpdate
Ord, ReadPrec [SqlErrorMensamNotOneUpdate]
ReadPrec SqlErrorMensamNotOneUpdate
Int -> ReadS SqlErrorMensamNotOneUpdate
ReadS [SqlErrorMensamNotOneUpdate]
(Int -> ReadS SqlErrorMensamNotOneUpdate)
-> ReadS [SqlErrorMensamNotOneUpdate]
-> ReadPrec SqlErrorMensamNotOneUpdate
-> ReadPrec [SqlErrorMensamNotOneUpdate]
-> Read SqlErrorMensamNotOneUpdate
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SqlErrorMensamNotOneUpdate
readsPrec :: Int -> ReadS SqlErrorMensamNotOneUpdate
$creadList :: ReadS [SqlErrorMensamNotOneUpdate]
readList :: ReadS [SqlErrorMensamNotOneUpdate]
$creadPrec :: ReadPrec SqlErrorMensamNotOneUpdate
readPrec :: ReadPrec SqlErrorMensamNotOneUpdate
$creadListPrec :: ReadPrec [SqlErrorMensamNotOneUpdate]
readListPrec :: ReadPrec [SqlErrorMensamNotOneUpdate]
Read, Int -> SqlErrorMensamNotOneUpdate -> ShowS
[SqlErrorMensamNotOneUpdate] -> ShowS
SqlErrorMensamNotOneUpdate -> String
(Int -> SqlErrorMensamNotOneUpdate -> ShowS)
-> (SqlErrorMensamNotOneUpdate -> String)
-> ([SqlErrorMensamNotOneUpdate] -> ShowS)
-> Show SqlErrorMensamNotOneUpdate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SqlErrorMensamNotOneUpdate -> ShowS
showsPrec :: Int -> SqlErrorMensamNotOneUpdate -> ShowS
$cshow :: SqlErrorMensamNotOneUpdate -> String
show :: SqlErrorMensamNotOneUpdate -> String
$cshowList :: [SqlErrorMensamNotOneUpdate] -> ShowS
showList :: [SqlErrorMensamNotOneUpdate] -> ShowS
Show)
  deriving anyclass (Show SqlErrorMensamNotOneUpdate
Typeable SqlErrorMensamNotOneUpdate
(Typeable SqlErrorMensamNotOneUpdate,
 Show SqlErrorMensamNotOneUpdate) =>
(SqlErrorMensamNotOneUpdate -> SomeException)
-> (SomeException -> Maybe SqlErrorMensamNotOneUpdate)
-> (SqlErrorMensamNotOneUpdate -> String)
-> Exception SqlErrorMensamNotOneUpdate
SomeException -> Maybe SqlErrorMensamNotOneUpdate
SqlErrorMensamNotOneUpdate -> String
SqlErrorMensamNotOneUpdate -> SomeException
forall e.
(Typeable e, Show e) =>
(e -> SomeException)
-> (SomeException -> Maybe e) -> (e -> String) -> Exception e
$ctoException :: SqlErrorMensamNotOneUpdate -> SomeException
toException :: SqlErrorMensamNotOneUpdate -> SomeException
$cfromException :: SomeException -> Maybe SqlErrorMensamNotOneUpdate
fromException :: SomeException -> Maybe SqlErrorMensamNotOneUpdate
$cdisplayException :: SqlErrorMensamNotOneUpdate -> String
displayException :: SqlErrorMensamNotOneUpdate -> String
Exception)

type SomeCol :: Type -> Type
data SomeCol t = forall a. SqlType a => MkSomeCol (Col t a)

orderFlexible ::
  Same s t =>
  (c -> SomeCol s) ->
  OrderByCategories c ->
  Query t ()
orderFlexible :: forall s t c.
Same s t =>
(c -> SomeCol s) -> OrderByCategories c -> Query t ()
orderFlexible c -> SomeCol s
_ (MkOrderByCategories []) = () -> Query t ()
forall a. a -> Query t a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
orderFlexible c -> SomeCol s
categoryToCol (MkOrderByCategories (OrderByCategory c
c : [OrderByCategory c]
cs)) =
  case c -> SomeCol s
categoryToCol (OrderByCategory c -> c
forall a. OrderByCategory a -> a
orderByCategoryCategory OrderByCategory c
c) of
    MkSomeCol Col s a
col -> do
      Col s a -> Order -> Query t ()
forall s t a.
(Same s t, SqlType a) =>
Col s a -> Order -> Query t ()
order Col s a
col (Order -> Order
translateOrder (Order -> Order) -> Order -> Order
forall a b. (a -> b) -> a -> b
$ OrderByCategory c -> Order
forall a. OrderByCategory a -> Order
orderByCategoryOrder OrderByCategory c
c)
      (c -> SomeCol s) -> OrderByCategories c -> Query t ()
forall s t c.
Same s t =>
(c -> SomeCol s) -> OrderByCategories c -> Query t ()
orderFlexible c -> SomeCol s
categoryToCol ([OrderByCategory c] -> OrderByCategories c
forall a. [OrderByCategory a] -> OrderByCategories a
MkOrderByCategories [OrderByCategory c]
cs)
 where
  translateOrder :: Mensam.API.Order.Order -> Database.Selda.Order
  translateOrder :: Order -> Order
translateOrder = \case
    Order
Ascending -> Order
ascending
    Order
Descending -> Order
descending

type SqlEnumStripPrefix :: Symbol -> Type -> Type
newtype SqlEnumStripPrefix prefix a = MkSqlEnumStripPrefix {forall (prefix :: Symbol) a. SqlEnumStripPrefix prefix a -> a
unSqlEnumStripPrefix :: a}
  deriving newtype (SqlEnumStripPrefix prefix a
SqlEnumStripPrefix prefix a
-> SqlEnumStripPrefix prefix a
-> Bounded (SqlEnumStripPrefix prefix a)
forall a. a -> a -> Bounded a
forall (prefix :: Symbol) a.
Bounded a =>
SqlEnumStripPrefix prefix a
$cminBound :: forall (prefix :: Symbol) a.
Bounded a =>
SqlEnumStripPrefix prefix a
minBound :: SqlEnumStripPrefix prefix a
$cmaxBound :: forall (prefix :: Symbol) a.
Bounded a =>
SqlEnumStripPrefix prefix a
maxBound :: SqlEnumStripPrefix prefix a
Bounded, Int -> SqlEnumStripPrefix prefix a
SqlEnumStripPrefix prefix a -> Int
SqlEnumStripPrefix prefix a -> [SqlEnumStripPrefix prefix a]
SqlEnumStripPrefix prefix a -> SqlEnumStripPrefix prefix a
SqlEnumStripPrefix prefix a
-> SqlEnumStripPrefix prefix a -> [SqlEnumStripPrefix prefix a]
SqlEnumStripPrefix prefix a
-> SqlEnumStripPrefix prefix a
-> SqlEnumStripPrefix prefix a
-> [SqlEnumStripPrefix prefix a]
(SqlEnumStripPrefix prefix a -> SqlEnumStripPrefix prefix a)
-> (SqlEnumStripPrefix prefix a -> SqlEnumStripPrefix prefix a)
-> (Int -> SqlEnumStripPrefix prefix a)
-> (SqlEnumStripPrefix prefix a -> Int)
-> (SqlEnumStripPrefix prefix a -> [SqlEnumStripPrefix prefix a])
-> (SqlEnumStripPrefix prefix a
    -> SqlEnumStripPrefix prefix a -> [SqlEnumStripPrefix prefix a])
-> (SqlEnumStripPrefix prefix a
    -> SqlEnumStripPrefix prefix a -> [SqlEnumStripPrefix prefix a])
-> (SqlEnumStripPrefix prefix a
    -> SqlEnumStripPrefix prefix a
    -> SqlEnumStripPrefix prefix a
    -> [SqlEnumStripPrefix prefix a])
-> Enum (SqlEnumStripPrefix prefix a)
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
forall (prefix :: Symbol) a.
Enum a =>
Int -> SqlEnumStripPrefix prefix a
forall (prefix :: Symbol) a.
Enum a =>
SqlEnumStripPrefix prefix a -> Int
forall (prefix :: Symbol) a.
Enum a =>
SqlEnumStripPrefix prefix a -> [SqlEnumStripPrefix prefix a]
forall (prefix :: Symbol) a.
Enum a =>
SqlEnumStripPrefix prefix a -> SqlEnumStripPrefix prefix a
forall (prefix :: Symbol) a.
Enum a =>
SqlEnumStripPrefix prefix a
-> SqlEnumStripPrefix prefix a -> [SqlEnumStripPrefix prefix a]
forall (prefix :: Symbol) a.
Enum a =>
SqlEnumStripPrefix prefix a
-> SqlEnumStripPrefix prefix a
-> SqlEnumStripPrefix prefix a
-> [SqlEnumStripPrefix prefix a]
$csucc :: forall (prefix :: Symbol) a.
Enum a =>
SqlEnumStripPrefix prefix a -> SqlEnumStripPrefix prefix a
succ :: SqlEnumStripPrefix prefix a -> SqlEnumStripPrefix prefix a
$cpred :: forall (prefix :: Symbol) a.
Enum a =>
SqlEnumStripPrefix prefix a -> SqlEnumStripPrefix prefix a
pred :: SqlEnumStripPrefix prefix a -> SqlEnumStripPrefix prefix a
$ctoEnum :: forall (prefix :: Symbol) a.
Enum a =>
Int -> SqlEnumStripPrefix prefix a
toEnum :: Int -> SqlEnumStripPrefix prefix a
$cfromEnum :: forall (prefix :: Symbol) a.
Enum a =>
SqlEnumStripPrefix prefix a -> Int
fromEnum :: SqlEnumStripPrefix prefix a -> Int
$cenumFrom :: forall (prefix :: Symbol) a.
Enum a =>
SqlEnumStripPrefix prefix a -> [SqlEnumStripPrefix prefix a]
enumFrom :: SqlEnumStripPrefix prefix a -> [SqlEnumStripPrefix prefix a]
$cenumFromThen :: forall (prefix :: Symbol) a.
Enum a =>
SqlEnumStripPrefix prefix a
-> SqlEnumStripPrefix prefix a -> [SqlEnumStripPrefix prefix a]
enumFromThen :: SqlEnumStripPrefix prefix a
-> SqlEnumStripPrefix prefix a -> [SqlEnumStripPrefix prefix a]
$cenumFromTo :: forall (prefix :: Symbol) a.
Enum a =>
SqlEnumStripPrefix prefix a
-> SqlEnumStripPrefix prefix a -> [SqlEnumStripPrefix prefix a]
enumFromTo :: SqlEnumStripPrefix prefix a
-> SqlEnumStripPrefix prefix a -> [SqlEnumStripPrefix prefix a]
$cenumFromThenTo :: forall (prefix :: Symbol) a.
Enum a =>
SqlEnumStripPrefix prefix a
-> SqlEnumStripPrefix prefix a
-> SqlEnumStripPrefix prefix a
-> [SqlEnumStripPrefix prefix a]
enumFromThenTo :: SqlEnumStripPrefix prefix a
-> SqlEnumStripPrefix prefix a
-> SqlEnumStripPrefix prefix a
-> [SqlEnumStripPrefix prefix a]
Enum)

instance (Typeable a, Bounded a, Enum a, Show a, Read a, KnownSymbol prefix) => SqlEnum (SqlEnumStripPrefix prefix a) where
  toText :: SqlEnumStripPrefix prefix a -> Text
toText = Maybe Text -> Text
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Text -> Text)
-> (SqlEnumStripPrefix prefix a -> Maybe Text)
-> SqlEnumStripPrefix prefix a
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> Maybe Text
T.stripPrefix (String -> Text
T.pack (Proxy prefix -> String
forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal (Proxy prefix -> String) -> Proxy prefix -> String
forall a b. (a -> b) -> a -> b
$ forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
Proxy @prefix)) (Text -> Maybe Text)
-> (SqlEnumStripPrefix prefix a -> Text)
-> SqlEnumStripPrefix prefix a
-> Maybe Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Text
T.pack (String -> Text) -> (a -> String) -> a -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show @a) (a -> Text)
-> (SqlEnumStripPrefix prefix a -> a)
-> SqlEnumStripPrefix prefix a
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqlEnumStripPrefix prefix a -> a
forall (prefix :: Symbol) a. SqlEnumStripPrefix prefix a -> a
unSqlEnumStripPrefix
  fromText :: Text -> SqlEnumStripPrefix prefix a
fromText = a -> SqlEnumStripPrefix prefix a
forall (prefix :: Symbol) a. a -> SqlEnumStripPrefix prefix a
MkSqlEnumStripPrefix (a -> SqlEnumStripPrefix prefix a)
-> (Text -> a) -> Text -> SqlEnumStripPrefix prefix a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. Read a => String -> a
read @a (String -> a) -> (Text -> String) -> Text -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack) (Text -> a) -> (Text -> Text) -> Text -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Text
T.pack (Proxy prefix -> String
forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal (Proxy prefix -> String) -> Proxy prefix -> String
forall a b. (a -> b) -> a -> b
$ forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
Proxy @prefix) <>)