-- | MSSQL Types Update
--
-- This module defines the Update-related IR types specific to MSSQL.
module Hasura.Backends.MSSQL.Types.Update
  ( BackendUpdate (..),
    UpdateOperator (..),
    Update (..),
    UpdateSet,
    UpdateOutput,
  )
where

import Hasura.Backends.MSSQL.Types.Instances ()
import Hasura.Backends.MSSQL.Types.Internal
import Hasura.Prelude

-- | The MSSQL-specific data of an Update expression.
--
-- This is parameterised over @v@ which enables different phases of IR
-- transformation to maintain the overall structure while enriching/transforming
-- the data at the leaves.
data BackendUpdate v = BackendUpdate
  { -- | The update operations to perform on each column.
    --
    -- This HashMap will also contain the update operators for the presets.
    -- They are populated as part of the schema building in
    -- 'Hasura.Backends.MSSQL.Instances.Schema.msBuildTableUpdateMutationFields'
    -- in the call to @buildUpdateOperators@.
    BackendUpdate v -> HashMap ColumnName (UpdateOperator v)
updateOperations :: HashMap ColumnName (UpdateOperator v)
  }
  deriving (a -> BackendUpdate b -> BackendUpdate a
(a -> b) -> BackendUpdate a -> BackendUpdate b
(forall a b. (a -> b) -> BackendUpdate a -> BackendUpdate b)
-> (forall a b. a -> BackendUpdate b -> BackendUpdate a)
-> Functor BackendUpdate
forall a b. a -> BackendUpdate b -> BackendUpdate a
forall a b. (a -> b) -> BackendUpdate a -> BackendUpdate b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> BackendUpdate b -> BackendUpdate a
$c<$ :: forall a b. a -> BackendUpdate b -> BackendUpdate a
fmap :: (a -> b) -> BackendUpdate a -> BackendUpdate b
$cfmap :: forall a b. (a -> b) -> BackendUpdate a -> BackendUpdate b
Functor, BackendUpdate a -> Bool
(a -> m) -> BackendUpdate a -> m
(a -> b -> b) -> b -> BackendUpdate a -> b
(forall m. Monoid m => BackendUpdate m -> m)
-> (forall m a. Monoid m => (a -> m) -> BackendUpdate a -> m)
-> (forall m a. Monoid m => (a -> m) -> BackendUpdate a -> m)
-> (forall a b. (a -> b -> b) -> b -> BackendUpdate a -> b)
-> (forall a b. (a -> b -> b) -> b -> BackendUpdate a -> b)
-> (forall b a. (b -> a -> b) -> b -> BackendUpdate a -> b)
-> (forall b a. (b -> a -> b) -> b -> BackendUpdate a -> b)
-> (forall a. (a -> a -> a) -> BackendUpdate a -> a)
-> (forall a. (a -> a -> a) -> BackendUpdate a -> a)
-> (forall a. BackendUpdate a -> [a])
-> (forall a. BackendUpdate a -> Bool)
-> (forall a. BackendUpdate a -> Int)
-> (forall a. Eq a => a -> BackendUpdate a -> Bool)
-> (forall a. Ord a => BackendUpdate a -> a)
-> (forall a. Ord a => BackendUpdate a -> a)
-> (forall a. Num a => BackendUpdate a -> a)
-> (forall a. Num a => BackendUpdate a -> a)
-> Foldable BackendUpdate
forall a. Eq a => a -> BackendUpdate a -> Bool
forall a. Num a => BackendUpdate a -> a
forall a. Ord a => BackendUpdate a -> a
forall m. Monoid m => BackendUpdate m -> m
forall a. BackendUpdate a -> Bool
forall a. BackendUpdate a -> Int
forall a. BackendUpdate a -> [a]
forall a. (a -> a -> a) -> BackendUpdate a -> a
forall m a. Monoid m => (a -> m) -> BackendUpdate a -> m
forall b a. (b -> a -> b) -> b -> BackendUpdate a -> b
forall a b. (a -> b -> b) -> b -> BackendUpdate a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: BackendUpdate a -> a
$cproduct :: forall a. Num a => BackendUpdate a -> a
sum :: BackendUpdate a -> a
$csum :: forall a. Num a => BackendUpdate a -> a
minimum :: BackendUpdate a -> a
$cminimum :: forall a. Ord a => BackendUpdate a -> a
maximum :: BackendUpdate a -> a
$cmaximum :: forall a. Ord a => BackendUpdate a -> a
elem :: a -> BackendUpdate a -> Bool
$celem :: forall a. Eq a => a -> BackendUpdate a -> Bool
length :: BackendUpdate a -> Int
$clength :: forall a. BackendUpdate a -> Int
null :: BackendUpdate a -> Bool
$cnull :: forall a. BackendUpdate a -> Bool
toList :: BackendUpdate a -> [a]
$ctoList :: forall a. BackendUpdate a -> [a]
foldl1 :: (a -> a -> a) -> BackendUpdate a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> BackendUpdate a -> a
foldr1 :: (a -> a -> a) -> BackendUpdate a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> BackendUpdate a -> a
foldl' :: (b -> a -> b) -> b -> BackendUpdate a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> BackendUpdate a -> b
foldl :: (b -> a -> b) -> b -> BackendUpdate a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> BackendUpdate a -> b
foldr' :: (a -> b -> b) -> b -> BackendUpdate a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> BackendUpdate a -> b
foldr :: (a -> b -> b) -> b -> BackendUpdate a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> BackendUpdate a -> b
foldMap' :: (a -> m) -> BackendUpdate a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> BackendUpdate a -> m
foldMap :: (a -> m) -> BackendUpdate a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> BackendUpdate a -> m
fold :: BackendUpdate m -> m
$cfold :: forall m. Monoid m => BackendUpdate m -> m
Foldable, Functor BackendUpdate
Foldable BackendUpdate
Functor BackendUpdate
-> Foldable BackendUpdate
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> BackendUpdate a -> f (BackendUpdate b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    BackendUpdate (f a) -> f (BackendUpdate a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> BackendUpdate a -> m (BackendUpdate b))
-> (forall (m :: * -> *) a.
    Monad m =>
    BackendUpdate (m a) -> m (BackendUpdate a))
-> Traversable BackendUpdate
(a -> f b) -> BackendUpdate a -> f (BackendUpdate b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
BackendUpdate (m a) -> m (BackendUpdate a)
forall (f :: * -> *) a.
Applicative f =>
BackendUpdate (f a) -> f (BackendUpdate a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> BackendUpdate a -> m (BackendUpdate b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> BackendUpdate a -> f (BackendUpdate b)
sequence :: BackendUpdate (m a) -> m (BackendUpdate a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
BackendUpdate (m a) -> m (BackendUpdate a)
mapM :: (a -> m b) -> BackendUpdate a -> m (BackendUpdate b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> BackendUpdate a -> m (BackendUpdate b)
sequenceA :: BackendUpdate (f a) -> f (BackendUpdate a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
BackendUpdate (f a) -> f (BackendUpdate a)
traverse :: (a -> f b) -> BackendUpdate a -> f (BackendUpdate b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> BackendUpdate a -> f (BackendUpdate b)
$cp2Traversable :: Foldable BackendUpdate
$cp1Traversable :: Functor BackendUpdate
Traversable, (forall x. BackendUpdate v -> Rep (BackendUpdate v) x)
-> (forall x. Rep (BackendUpdate v) x -> BackendUpdate v)
-> Generic (BackendUpdate v)
forall x. Rep (BackendUpdate v) x -> BackendUpdate v
forall x. BackendUpdate v -> Rep (BackendUpdate v) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall v x. Rep (BackendUpdate v) x -> BackendUpdate v
forall v x. BackendUpdate v -> Rep (BackendUpdate v) x
$cto :: forall v x. Rep (BackendUpdate v) x -> BackendUpdate v
$cfrom :: forall v x. BackendUpdate v -> Rep (BackendUpdate v) x
Generic, Typeable (BackendUpdate v)
DataType
Constr
Typeable (BackendUpdate v)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BackendUpdate v -> c (BackendUpdate v))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (BackendUpdate v))
-> (BackendUpdate v -> Constr)
-> (BackendUpdate v -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (BackendUpdate v)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (BackendUpdate v)))
-> ((forall b. Data b => b -> b)
    -> BackendUpdate v -> BackendUpdate v)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BackendUpdate v -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BackendUpdate v -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> BackendUpdate v -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BackendUpdate v -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> BackendUpdate v -> m (BackendUpdate v))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BackendUpdate v -> m (BackendUpdate v))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BackendUpdate v -> m (BackendUpdate v))
-> Data (BackendUpdate v)
BackendUpdate v -> DataType
BackendUpdate v -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (BackendUpdate v))
(forall b. Data b => b -> b) -> BackendUpdate v -> BackendUpdate v
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BackendUpdate v -> c (BackendUpdate v)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BackendUpdate v)
forall v. Data v => Typeable (BackendUpdate v)
forall v. Data v => BackendUpdate v -> DataType
forall v. Data v => BackendUpdate v -> Constr
forall v.
Data v =>
(forall b. Data b => b -> b) -> BackendUpdate v -> BackendUpdate v
forall v u.
Data v =>
Int -> (forall d. Data d => d -> u) -> BackendUpdate v -> u
forall v u.
Data v =>
(forall d. Data d => d -> u) -> BackendUpdate v -> [u]
forall v r r'.
Data v =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BackendUpdate v -> r
forall v r r'.
Data v =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BackendUpdate v -> r
forall v (m :: * -> *).
(Data v, Monad m) =>
(forall d. Data d => d -> m d)
-> BackendUpdate v -> m (BackendUpdate v)
forall v (m :: * -> *).
(Data v, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> BackendUpdate v -> m (BackendUpdate v)
forall v (c :: * -> *).
Data v =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BackendUpdate v)
forall v (c :: * -> *).
Data v =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BackendUpdate v -> c (BackendUpdate v)
forall v (t :: * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (BackendUpdate v))
forall v (t :: * -> * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BackendUpdate v))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> BackendUpdate v -> u
forall u. (forall d. Data d => d -> u) -> BackendUpdate v -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BackendUpdate v -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BackendUpdate v -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BackendUpdate v -> m (BackendUpdate v)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BackendUpdate v -> m (BackendUpdate v)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BackendUpdate v)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BackendUpdate v -> c (BackendUpdate v)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (BackendUpdate v))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BackendUpdate v))
$cBackendUpdate :: Constr
$tBackendUpdate :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> BackendUpdate v -> m (BackendUpdate v)
$cgmapMo :: forall v (m :: * -> *).
(Data v, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> BackendUpdate v -> m (BackendUpdate v)
gmapMp :: (forall d. Data d => d -> m d)
-> BackendUpdate v -> m (BackendUpdate v)
$cgmapMp :: forall v (m :: * -> *).
(Data v, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> BackendUpdate v -> m (BackendUpdate v)
gmapM :: (forall d. Data d => d -> m d)
-> BackendUpdate v -> m (BackendUpdate v)
$cgmapM :: forall v (m :: * -> *).
(Data v, Monad m) =>
(forall d. Data d => d -> m d)
-> BackendUpdate v -> m (BackendUpdate v)
gmapQi :: Int -> (forall d. Data d => d -> u) -> BackendUpdate v -> u
$cgmapQi :: forall v u.
Data v =>
Int -> (forall d. Data d => d -> u) -> BackendUpdate v -> u
gmapQ :: (forall d. Data d => d -> u) -> BackendUpdate v -> [u]
$cgmapQ :: forall v u.
Data v =>
(forall d. Data d => d -> u) -> BackendUpdate v -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BackendUpdate v -> r
$cgmapQr :: forall v r r'.
Data v =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BackendUpdate v -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BackendUpdate v -> r
$cgmapQl :: forall v r r'.
Data v =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BackendUpdate v -> r
gmapT :: (forall b. Data b => b -> b) -> BackendUpdate v -> BackendUpdate v
$cgmapT :: forall v.
Data v =>
(forall b. Data b => b -> b) -> BackendUpdate v -> BackendUpdate v
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BackendUpdate v))
$cdataCast2 :: forall v (t :: * -> * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BackendUpdate v))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (BackendUpdate v))
$cdataCast1 :: forall v (t :: * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (BackendUpdate v))
dataTypeOf :: BackendUpdate v -> DataType
$cdataTypeOf :: forall v. Data v => BackendUpdate v -> DataType
toConstr :: BackendUpdate v -> Constr
$ctoConstr :: forall v. Data v => BackendUpdate v -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BackendUpdate v)
$cgunfold :: forall v (c :: * -> *).
Data v =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BackendUpdate v)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BackendUpdate v -> c (BackendUpdate v)
$cgfoldl :: forall v (c :: * -> *).
Data v =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BackendUpdate v -> c (BackendUpdate v)
$cp1Data :: forall v. Data v => Typeable (BackendUpdate v)
Data)

-- | The various @update operators@ supported by MSSQL,
-- i.e. the @_set@, @_inc@ operators that appear in the schema.
--
-- TODO: Docs for MSSQL!
-- See <https://hasura.io/docs/latest/graphql/core/databases/postgres/mutations/update.html#postgres-update-mutation Update Mutations User docs>
data UpdateOperator v
  = UpdateSet v
  | UpdateInc v
  deriving (a -> UpdateOperator b -> UpdateOperator a
(a -> b) -> UpdateOperator a -> UpdateOperator b
(forall a b. (a -> b) -> UpdateOperator a -> UpdateOperator b)
-> (forall a b. a -> UpdateOperator b -> UpdateOperator a)
-> Functor UpdateOperator
forall a b. a -> UpdateOperator b -> UpdateOperator a
forall a b. (a -> b) -> UpdateOperator a -> UpdateOperator b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> UpdateOperator b -> UpdateOperator a
$c<$ :: forall a b. a -> UpdateOperator b -> UpdateOperator a
fmap :: (a -> b) -> UpdateOperator a -> UpdateOperator b
$cfmap :: forall a b. (a -> b) -> UpdateOperator a -> UpdateOperator b
Functor, UpdateOperator a -> Bool
(a -> m) -> UpdateOperator a -> m
(a -> b -> b) -> b -> UpdateOperator a -> b
(forall m. Monoid m => UpdateOperator m -> m)
-> (forall m a. Monoid m => (a -> m) -> UpdateOperator a -> m)
-> (forall m a. Monoid m => (a -> m) -> UpdateOperator a -> m)
-> (forall a b. (a -> b -> b) -> b -> UpdateOperator a -> b)
-> (forall a b. (a -> b -> b) -> b -> UpdateOperator a -> b)
-> (forall b a. (b -> a -> b) -> b -> UpdateOperator a -> b)
-> (forall b a. (b -> a -> b) -> b -> UpdateOperator a -> b)
-> (forall a. (a -> a -> a) -> UpdateOperator a -> a)
-> (forall a. (a -> a -> a) -> UpdateOperator a -> a)
-> (forall a. UpdateOperator a -> [a])
-> (forall a. UpdateOperator a -> Bool)
-> (forall a. UpdateOperator a -> Int)
-> (forall a. Eq a => a -> UpdateOperator a -> Bool)
-> (forall a. Ord a => UpdateOperator a -> a)
-> (forall a. Ord a => UpdateOperator a -> a)
-> (forall a. Num a => UpdateOperator a -> a)
-> (forall a. Num a => UpdateOperator a -> a)
-> Foldable UpdateOperator
forall a. Eq a => a -> UpdateOperator a -> Bool
forall a. Num a => UpdateOperator a -> a
forall a. Ord a => UpdateOperator a -> a
forall m. Monoid m => UpdateOperator m -> m
forall a. UpdateOperator a -> Bool
forall a. UpdateOperator a -> Int
forall a. UpdateOperator a -> [a]
forall a. (a -> a -> a) -> UpdateOperator a -> a
forall m a. Monoid m => (a -> m) -> UpdateOperator a -> m
forall b a. (b -> a -> b) -> b -> UpdateOperator a -> b
forall a b. (a -> b -> b) -> b -> UpdateOperator a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: UpdateOperator a -> a
$cproduct :: forall a. Num a => UpdateOperator a -> a
sum :: UpdateOperator a -> a
$csum :: forall a. Num a => UpdateOperator a -> a
minimum :: UpdateOperator a -> a
$cminimum :: forall a. Ord a => UpdateOperator a -> a
maximum :: UpdateOperator a -> a
$cmaximum :: forall a. Ord a => UpdateOperator a -> a
elem :: a -> UpdateOperator a -> Bool
$celem :: forall a. Eq a => a -> UpdateOperator a -> Bool
length :: UpdateOperator a -> Int
$clength :: forall a. UpdateOperator a -> Int
null :: UpdateOperator a -> Bool
$cnull :: forall a. UpdateOperator a -> Bool
toList :: UpdateOperator a -> [a]
$ctoList :: forall a. UpdateOperator a -> [a]
foldl1 :: (a -> a -> a) -> UpdateOperator a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> UpdateOperator a -> a
foldr1 :: (a -> a -> a) -> UpdateOperator a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> UpdateOperator a -> a
foldl' :: (b -> a -> b) -> b -> UpdateOperator a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> UpdateOperator a -> b
foldl :: (b -> a -> b) -> b -> UpdateOperator a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> UpdateOperator a -> b
foldr' :: (a -> b -> b) -> b -> UpdateOperator a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> UpdateOperator a -> b
foldr :: (a -> b -> b) -> b -> UpdateOperator a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> UpdateOperator a -> b
foldMap' :: (a -> m) -> UpdateOperator a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> UpdateOperator a -> m
foldMap :: (a -> m) -> UpdateOperator a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> UpdateOperator a -> m
fold :: UpdateOperator m -> m
$cfold :: forall m. Monoid m => UpdateOperator m -> m
Foldable, Functor UpdateOperator
Foldable UpdateOperator
Functor UpdateOperator
-> Foldable UpdateOperator
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> UpdateOperator a -> f (UpdateOperator b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    UpdateOperator (f a) -> f (UpdateOperator a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> UpdateOperator a -> m (UpdateOperator b))
-> (forall (m :: * -> *) a.
    Monad m =>
    UpdateOperator (m a) -> m (UpdateOperator a))
-> Traversable UpdateOperator
(a -> f b) -> UpdateOperator a -> f (UpdateOperator b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
UpdateOperator (m a) -> m (UpdateOperator a)
forall (f :: * -> *) a.
Applicative f =>
UpdateOperator (f a) -> f (UpdateOperator a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> UpdateOperator a -> m (UpdateOperator b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> UpdateOperator a -> f (UpdateOperator b)
sequence :: UpdateOperator (m a) -> m (UpdateOperator a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
UpdateOperator (m a) -> m (UpdateOperator a)
mapM :: (a -> m b) -> UpdateOperator a -> m (UpdateOperator b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> UpdateOperator a -> m (UpdateOperator b)
sequenceA :: UpdateOperator (f a) -> f (UpdateOperator a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
UpdateOperator (f a) -> f (UpdateOperator a)
traverse :: (a -> f b) -> UpdateOperator a -> f (UpdateOperator b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> UpdateOperator a -> f (UpdateOperator b)
$cp2Traversable :: Foldable UpdateOperator
$cp1Traversable :: Functor UpdateOperator
Traversable, (forall x. UpdateOperator v -> Rep (UpdateOperator v) x)
-> (forall x. Rep (UpdateOperator v) x -> UpdateOperator v)
-> Generic (UpdateOperator v)
forall x. Rep (UpdateOperator v) x -> UpdateOperator v
forall x. UpdateOperator v -> Rep (UpdateOperator v) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall v x. Rep (UpdateOperator v) x -> UpdateOperator v
forall v x. UpdateOperator v -> Rep (UpdateOperator v) x
$cto :: forall v x. Rep (UpdateOperator v) x -> UpdateOperator v
$cfrom :: forall v x. UpdateOperator v -> Rep (UpdateOperator v) x
Generic, Typeable (UpdateOperator v)
DataType
Constr
Typeable (UpdateOperator v)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> UpdateOperator v
    -> c (UpdateOperator v))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (UpdateOperator v))
-> (UpdateOperator v -> Constr)
-> (UpdateOperator v -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (UpdateOperator v)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (UpdateOperator v)))
-> ((forall b. Data b => b -> b)
    -> UpdateOperator v -> UpdateOperator v)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> UpdateOperator v -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> UpdateOperator v -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> UpdateOperator v -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> UpdateOperator v -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> UpdateOperator v -> m (UpdateOperator v))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> UpdateOperator v -> m (UpdateOperator v))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> UpdateOperator v -> m (UpdateOperator v))
-> Data (UpdateOperator v)
UpdateOperator v -> DataType
UpdateOperator v -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (UpdateOperator v))
(forall b. Data b => b -> b)
-> UpdateOperator v -> UpdateOperator v
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UpdateOperator v -> c (UpdateOperator v)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (UpdateOperator v)
forall v. Data v => Typeable (UpdateOperator v)
forall v. Data v => UpdateOperator v -> DataType
forall v. Data v => UpdateOperator v -> Constr
forall v.
Data v =>
(forall b. Data b => b -> b)
-> UpdateOperator v -> UpdateOperator v
forall v u.
Data v =>
Int -> (forall d. Data d => d -> u) -> UpdateOperator v -> u
forall v u.
Data v =>
(forall d. Data d => d -> u) -> UpdateOperator v -> [u]
forall v r r'.
Data v =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UpdateOperator v -> r
forall v r r'.
Data v =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UpdateOperator v -> r
forall v (m :: * -> *).
(Data v, Monad m) =>
(forall d. Data d => d -> m d)
-> UpdateOperator v -> m (UpdateOperator v)
forall v (m :: * -> *).
(Data v, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> UpdateOperator v -> m (UpdateOperator v)
forall v (c :: * -> *).
Data v =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (UpdateOperator v)
forall v (c :: * -> *).
Data v =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UpdateOperator v -> c (UpdateOperator v)
forall v (t :: * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (UpdateOperator v))
forall v (t :: * -> * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (UpdateOperator v))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> UpdateOperator v -> u
forall u. (forall d. Data d => d -> u) -> UpdateOperator v -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UpdateOperator v -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UpdateOperator v -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> UpdateOperator v -> m (UpdateOperator v)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UpdateOperator v -> m (UpdateOperator v)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (UpdateOperator v)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UpdateOperator v -> c (UpdateOperator v)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (UpdateOperator v))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (UpdateOperator v))
$cUpdateInc :: Constr
$cUpdateSet :: Constr
$tUpdateOperator :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> UpdateOperator v -> m (UpdateOperator v)
$cgmapMo :: forall v (m :: * -> *).
(Data v, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> UpdateOperator v -> m (UpdateOperator v)
gmapMp :: (forall d. Data d => d -> m d)
-> UpdateOperator v -> m (UpdateOperator v)
$cgmapMp :: forall v (m :: * -> *).
(Data v, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> UpdateOperator v -> m (UpdateOperator v)
gmapM :: (forall d. Data d => d -> m d)
-> UpdateOperator v -> m (UpdateOperator v)
$cgmapM :: forall v (m :: * -> *).
(Data v, Monad m) =>
(forall d. Data d => d -> m d)
-> UpdateOperator v -> m (UpdateOperator v)
gmapQi :: Int -> (forall d. Data d => d -> u) -> UpdateOperator v -> u
$cgmapQi :: forall v u.
Data v =>
Int -> (forall d. Data d => d -> u) -> UpdateOperator v -> u
gmapQ :: (forall d. Data d => d -> u) -> UpdateOperator v -> [u]
$cgmapQ :: forall v u.
Data v =>
(forall d. Data d => d -> u) -> UpdateOperator v -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UpdateOperator v -> r
$cgmapQr :: forall v r r'.
Data v =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UpdateOperator v -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UpdateOperator v -> r
$cgmapQl :: forall v r r'.
Data v =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UpdateOperator v -> r
gmapT :: (forall b. Data b => b -> b)
-> UpdateOperator v -> UpdateOperator v
$cgmapT :: forall v.
Data v =>
(forall b. Data b => b -> b)
-> UpdateOperator v -> UpdateOperator v
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (UpdateOperator v))
$cdataCast2 :: forall v (t :: * -> * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (UpdateOperator v))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (UpdateOperator v))
$cdataCast1 :: forall v (t :: * -> *) (c :: * -> *).
(Data v, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (UpdateOperator v))
dataTypeOf :: UpdateOperator v -> DataType
$cdataTypeOf :: forall v. Data v => UpdateOperator v -> DataType
toConstr :: UpdateOperator v -> Constr
$ctoConstr :: forall v. Data v => UpdateOperator v -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (UpdateOperator v)
$cgunfold :: forall v (c :: * -> *).
Data v =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (UpdateOperator v)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UpdateOperator v -> c (UpdateOperator v)
$cgfoldl :: forall v (c :: * -> *).
Data v =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UpdateOperator v -> c (UpdateOperator v)
$cp1Data :: forall v. Data v => Typeable (UpdateOperator v)
Data)

type UpdateSet = HashMap ColumnName (UpdateOperator Expression)

type UpdateOutput = Output Inserted

-- | UPDATE [table_alias] SET [table_alias].column = 'value' OUTPUT INSERTED.column INTO #updated
-- FROM [table_name] AS [table_alias] WHERE <filter-expression>
data Update = Update
  { Update -> Aliased TableName
updateTable :: Aliased TableName,
    Update -> UpdateSet
updateSet :: UpdateSet,
    Update -> UpdateOutput
updateOutput :: UpdateOutput,
    Update -> TempTable
updateTempTable :: TempTable,
    Update -> Where
updateWhere :: Where
  }