-- |
-- Module      : Database.Relational.Type
-- Copyright   : 2013-2019 Kei Hibino
-- License     : BSD3
--
-- Maintainer  : ex8k.hibino@gmail.com
-- Stability   : experimental
-- Portability : unknown
--
-- This module defines typed SQL.
module Database.Relational.Type (
  -- * Typed query statement
  Query (..), unsafeTypedQuery,

  relationalQuery_,
  relationalQuery', relationalQuery,

  relationalQuerySQL,

  -- * Typed update statement
  KeyUpdate (..), unsafeTypedKeyUpdate, typedKeyUpdate, typedKeyUpdateTable, keyUpdate,
  Update (..), unsafeTypedUpdate, typedUpdate', update', update, updateNoPH,
  typedUpdateAllColumn, updateAllColumn', updateAllColumn, updateAllColumnNoPH,

  updateSQL,

  -- * Typed insert statement
  Insert (..), untypeChunkInsert, chunkSizeOfInsert,
  unsafeTypedInsert', unsafeTypedInsert, typedInsert', insert,
  typedInsertValue', insertValue', insertValue, insertValueNoPH,
  insertValueList', insertValueList,
  InsertQuery (..), unsafeTypedInsertQuery,
  typedInsertQuery', insertQuery', insertQuery,

  insertQuerySQL,

  -- * Typed delete statement
  Delete (..), unsafeTypedDelete, typedDelete', delete', delete, deleteNoPH,

  deleteSQL,

  -- * Generalized interfaces
  UntypeableNoFetch (..),

  -- * Deprecated

  typedUpdate,
  typedInsert, typedInsertValue, typedInsertQuery,
  typedDelete,

  derivedKeyUpdate,
  derivedUpdate', derivedUpdate,
  derivedUpdateAllColumn', derivedUpdateAllColumn,

  derivedInsert,
  derivedInsertValue', derivedInsertValue,
  derivedInsertQuery,

  derivedDelete', derivedDelete,
  ) where

import Data.Monoid ((<>))
import Data.Functor.ProductIsomorphic (peRight)

import Database.Record (PersistableWidth)

import Database.Relational.Internal.Config (Config, defaultConfig)
import Database.Relational.Internal.ContextType (Flat)
import Database.Relational.Internal.String (showStringSQL)
import Database.Relational.SqlSyntax (Record)

import Database.Relational.Monad.BaseType (Relation, sqlFromRelationWith)
import Database.Relational.Monad.Restrict (Restrict)
import Database.Relational.Monad.Assign (Assign)
import Database.Relational.Monad.Register (Register)
import Database.Relational.Relation (tableOf)
import Database.Relational.Effect
  (liftTargetAllColumn', InsertTarget, insertTarget',
   deleteFromRestriction, updateFromUpdateTarget, piRegister,
   sqlChunkFromInsertTarget, sqlFromInsertTarget, sqlChunksFromRecordList)
import Database.Relational.Pi (Pi)
import Database.Relational.Table (Table, TableDerivable, derivedTable)
import Database.Relational.ProjectableClass (LiteralSQL)
import Database.Relational.Projectable (PlaceHolders, unitPH)
import Database.Relational.SimpleSql
  (QuerySuffix, showsQuerySuffix, insertPrefixSQL, updateOtherThanKeySQL, )


-- | Query type with place-holder parameter 'p' and query result type 'a'.
newtype Query p a = Query { Query p a -> String
untypeQuery :: String }

-- | Unsafely make typed 'Query' from SQL string.
unsafeTypedQuery :: String    -- ^ Query SQL to type
                 -> Query p a -- ^ Typed result
unsafeTypedQuery :: String -> Query p a
unsafeTypedQuery =  String -> Query p a
forall p a. String -> Query p a
Query

-- | Show query SQL string
instance Show (Query p a) where
  show :: Query p a -> String
show = Query p a -> String
forall p a. Query p a -> String
untypeQuery

-- | From 'Relation' into untyped SQL query string.
relationalQuerySQL :: Config -> Relation p r -> QuerySuffix -> String
relationalQuerySQL :: Config -> Relation p r -> QuerySuffix -> String
relationalQuerySQL Config
config Relation p r
rel QuerySuffix
qsuf =
  StringSQL -> String
showStringSQL (StringSQL -> String) -> StringSQL -> String
forall a b. (a -> b) -> a -> b
$ Relation p r -> Config -> StringSQL
forall p r. Relation p r -> Config -> StringSQL
sqlFromRelationWith Relation p r
rel Config
config StringSQL -> StringSQL -> StringSQL
forall a. Semigroup a => a -> a -> a
<> QuerySuffix -> StringSQL
showsQuerySuffix QuerySuffix
qsuf

-- | From 'Relation' into typed 'Query' with suffix SQL words.
relationalQuery_ :: Config -> Relation p r -> QuerySuffix -> Query p r
relationalQuery_ :: Config -> Relation p r -> QuerySuffix -> Query p r
relationalQuery_ Config
config Relation p r
rel QuerySuffix
qsuf =
  String -> Query p r
forall p a. String -> Query p a
unsafeTypedQuery (String -> Query p r) -> String -> Query p r
forall a b. (a -> b) -> a -> b
$ Config -> Relation p r -> QuerySuffix -> String
forall p r. Config -> Relation p r -> QuerySuffix -> String
relationalQuerySQL Config
config Relation p r
rel QuerySuffix
qsuf

-- | From 'Relation' into typed 'Query' with suffix SQL words.
relationalQuery' :: Relation p r -> QuerySuffix -> Query p r
relationalQuery' :: Relation p r -> QuerySuffix -> Query p r
relationalQuery' = Config -> Relation p r -> QuerySuffix -> Query p r
forall p r. Config -> Relation p r -> QuerySuffix -> Query p r
relationalQuery_ Config
defaultConfig

-- | From 'Relation' into typed 'Query'.
relationalQuery :: Relation p r -> Query p r
relationalQuery :: Relation p r -> Query p r
relationalQuery =  (Relation p r -> QuerySuffix -> Query p r
forall p r. Relation p r -> QuerySuffix -> Query p r
`relationalQuery'` [])


-- | Update type with key type 'p' and update record type 'a'.
--   Columns to update are record columns other than key columns,
--   So place-holder parameter type is the same as record type 'a'.
data KeyUpdate p a = KeyUpdate { KeyUpdate p a -> Pi a p
updateKey :: Pi a p
                               , KeyUpdate p a -> String
untypeKeyUpdate :: String
                               }

-- | Unsafely make typed 'KeyUpdate' from SQL string.
unsafeTypedKeyUpdate :: Pi a p -> String -> KeyUpdate p a
unsafeTypedKeyUpdate :: Pi a p -> String -> KeyUpdate p a
unsafeTypedKeyUpdate =  Pi a p -> String -> KeyUpdate p a
forall p a. Pi a p -> String -> KeyUpdate p a
KeyUpdate

-- | Make typed 'KeyUpdate' from 'Table' and key columns selector 'Pi'.
typedKeyUpdate :: Table a -> Pi a p -> KeyUpdate p a
typedKeyUpdate :: Table a -> Pi a p -> KeyUpdate p a
typedKeyUpdate Table a
tbl Pi a p
key = Pi a p -> String -> KeyUpdate p a
forall a p. Pi a p -> String -> KeyUpdate p a
unsafeTypedKeyUpdate Pi a p
key (String -> KeyUpdate p a) -> String -> KeyUpdate p a
forall a b. (a -> b) -> a -> b
$ Table a -> Pi a p -> String
forall r p. Table r -> Pi r p -> String
updateOtherThanKeySQL Table a
tbl Pi a p
key

-- | Make typed 'KeyUpdate' object using derived info specified by 'Relation' type.
typedKeyUpdateTable :: TableDerivable r => Relation () r -> Pi r p -> KeyUpdate p r
typedKeyUpdateTable :: Relation () r -> Pi r p -> KeyUpdate p r
typedKeyUpdateTable =  Table r -> Pi r p -> KeyUpdate p r
forall a p. Table a -> Pi a p -> KeyUpdate p a
typedKeyUpdate (Table r -> Pi r p -> KeyUpdate p r)
-> (Relation () r -> Table r)
-> Relation () r
-> Pi r p
-> KeyUpdate p r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Relation () r -> Table r
forall r. TableDerivable r => Relation () r -> Table r
tableOf

-- keyUpdate'
-- Config parameter is not yet required for KeyUpdate.

-- | Make typed 'KeyUpdate' from derived table and key columns selector 'Pi'.
keyUpdate :: TableDerivable r => Pi r p -> KeyUpdate p r
keyUpdate :: Pi r p -> KeyUpdate p r
keyUpdate = Table r -> Pi r p -> KeyUpdate p r
forall a p. Table a -> Pi a p -> KeyUpdate p a
typedKeyUpdate Table r
forall r. TableDerivable r => Table r
derivedTable

{-# DEPRECATED derivedKeyUpdate "use keyUpdate instead of this." #-}
-- | Make typed 'KeyUpdate' from derived table and key columns selector 'Pi'.
derivedKeyUpdate :: TableDerivable r => Pi r p -> KeyUpdate p r
derivedKeyUpdate :: Pi r p -> KeyUpdate p r
derivedKeyUpdate = Pi r p -> KeyUpdate p r
forall r p. TableDerivable r => Pi r p -> KeyUpdate p r
keyUpdate

-- | Show update SQL string
instance Show (KeyUpdate p a) where
  show :: KeyUpdate p a -> String
show = KeyUpdate p a -> String
forall p a. KeyUpdate p a -> String
untypeKeyUpdate


-- | Update type with place-holder parameter 'p'.
newtype Update p = Update { Update p -> String
untypeUpdate :: String }

-- | Unsafely make typed 'Update' from SQL string.
unsafeTypedUpdate :: String -> Update p
unsafeTypedUpdate :: String -> Update p
unsafeTypedUpdate =  String -> Update p
forall p. String -> Update p
Update

-- | Make untyped update SQL string from 'Table' and 'Assign' computation.
updateSQL :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> String
updateSQL :: Config
-> Table r
-> (Record Flat r -> Assign r (PlaceHolders p))
-> String
updateSQL Config
config Table r
tbl Record Flat r -> Assign r (PlaceHolders p)
ut = StringSQL -> String
showStringSQL (StringSQL -> String) -> StringSQL -> String
forall a b. (a -> b) -> a -> b
$ Config
-> Table r
-> (Record Flat r -> Assign r (PlaceHolders p))
-> StringSQL
forall r p.
Config
-> Table r
-> (Record Flat r -> Assign r (PlaceHolders p))
-> StringSQL
updateFromUpdateTarget Config
config Table r
tbl Record Flat r -> Assign r (PlaceHolders p)
ut

-- | Make typed 'Update' from 'Config', 'Table' and 'Assign' computation.
typedUpdate' :: Config -> Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
typedUpdate' :: Config
-> Table r
-> (Record Flat r -> Assign r (PlaceHolders p))
-> Update p
typedUpdate' Config
config Table r
tbl Record Flat r -> Assign r (PlaceHolders p)
ut = String -> Update p
forall p. String -> Update p
unsafeTypedUpdate (String -> Update p) -> String -> Update p
forall a b. (a -> b) -> a -> b
$ Config
-> Table r
-> (Record Flat r -> Assign r (PlaceHolders p))
-> String
forall r p.
Config
-> Table r
-> (Record Flat r -> Assign r (PlaceHolders p))
-> String
updateSQL Config
config Table r
tbl Record Flat r -> Assign r (PlaceHolders p)
ut

{-# DEPRECATED typedUpdate "use `typedUpdate' defaultConfig` instead of this." #-}
-- | Make typed 'Update' using 'defaultConfig', 'Table' and 'Assign' computation.
typedUpdate :: Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
typedUpdate :: Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
typedUpdate =  Config
-> Table r
-> (Record Flat r -> Assign r (PlaceHolders p))
-> Update p
forall r p.
Config
-> Table r
-> (Record Flat r -> Assign r (PlaceHolders p))
-> Update p
typedUpdate' Config
defaultConfig

targetTable :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Table r
targetTable :: (Record Flat r -> Assign r (PlaceHolders p)) -> Table r
targetTable =  Table r -> (Record Flat r -> Assign r (PlaceHolders p)) -> Table r
forall a b. a -> b -> a
const Table r
forall r. TableDerivable r => Table r
derivedTable

-- | Make typed 'Update' from 'Config', derived table and 'Assign' computation.
update' :: TableDerivable r => Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
update' :: Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
update' Config
config Record Flat r -> Assign r (PlaceHolders p)
ac =  Config
-> Table r
-> (Record Flat r -> Assign r (PlaceHolders p))
-> Update p
forall r p.
Config
-> Table r
-> (Record Flat r -> Assign r (PlaceHolders p))
-> Update p
typedUpdate' Config
config ((Record Flat r -> Assign r (PlaceHolders p)) -> Table r
forall r p.
TableDerivable r =>
(Record Flat r -> Assign r (PlaceHolders p)) -> Table r
targetTable Record Flat r -> Assign r (PlaceHolders p)
ac) Record Flat r -> Assign r (PlaceHolders p)
ac

{-# DEPRECATED derivedUpdate' "use `update'` instead of this." #-}
-- | Make typed 'Update' from 'Config', derived table and 'Assign' computation.
derivedUpdate' :: TableDerivable r => Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
derivedUpdate' :: Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
derivedUpdate' = Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
forall r p.
TableDerivable r =>
Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
update'

-- | Make typed 'Update' from 'defaultConfig', derived table and 'Assign' computation.
update :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
update :: (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
update = Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
forall r p.
TableDerivable r =>
Config -> (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
update' Config
defaultConfig

-- | Make typed 'Update' from 'defaultConfig', derived table and 'Assign' computation with no(unit) placeholder.
updateNoPH :: TableDerivable r => (Record Flat r -> Assign r ()) -> Update ()
updateNoPH :: (Record Flat r -> Assign r ()) -> Update ()
updateNoPH Record Flat r -> Assign r ()
af = (Record Flat r -> Assign r (PlaceHolders ())) -> Update ()
forall r p.
TableDerivable r =>
(Record Flat r -> Assign r (PlaceHolders p)) -> Update p
update ((Record Flat r -> Assign r (PlaceHolders ())) -> Update ())
-> (Record Flat r -> Assign r (PlaceHolders ())) -> Update ()
forall a b. (a -> b) -> a -> b
$ (Assign r ()
-> Assign r (PlaceHolders ()) -> Assign r (PlaceHolders ())
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> PlaceHolders () -> Assign r (PlaceHolders ())
forall (m :: * -> *) a. Monad m => a -> m a
return PlaceHolders ()
unitPH) (Assign r () -> Assign r (PlaceHolders ()))
-> (Record Flat r -> Assign r ())
-> Record Flat r
-> Assign r (PlaceHolders ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Record Flat r -> Assign r ()
af

{-# DEPRECATED derivedUpdate "use `update` instead of this." #-}
-- | Make typed 'Update' from 'defaultConfig', derived table and 'Assign' computation.
derivedUpdate :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
derivedUpdate :: (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
derivedUpdate = (Record Flat r -> Assign r (PlaceHolders p)) -> Update p
forall r p.
TableDerivable r =>
(Record Flat r -> Assign r (PlaceHolders p)) -> Update p
update


-- | Make typed 'Update' from 'Config', 'Table' and 'Restrict' computation.
--   Update target is all column.
typedUpdateAllColumn' :: PersistableWidth r
                      => Config
                      -> Table r
                      -> (Record Flat r -> Restrict (PlaceHolders p))
                      -> Update (r, p)
typedUpdateAllColumn' :: Config
-> Table r
-> (Record Flat r -> Restrict (PlaceHolders p))
-> Update (r, p)
typedUpdateAllColumn' Config
config Table r
tbl Record Flat r -> Restrict (PlaceHolders p)
r = Config
-> Table r
-> (Record Flat r -> Assign r (PlaceHolders (r, p)))
-> Update (r, p)
forall r p.
Config
-> Table r
-> (Record Flat r -> Assign r (PlaceHolders p))
-> Update p
typedUpdate' Config
config Table r
tbl ((Record Flat r -> Assign r (PlaceHolders (r, p)))
 -> Update (r, p))
-> (Record Flat r -> Assign r (PlaceHolders (r, p)))
-> Update (r, p)
forall a b. (a -> b) -> a -> b
$ (Record Flat r -> Restrict (PlaceHolders p))
-> Record Flat r -> Assign r (PlaceHolders (r, p))
forall r p.
PersistableWidth r =>
(Record Flat r -> Restrict (PlaceHolders p))
-> Record Flat r -> Assign r (PlaceHolders (r, p))
liftTargetAllColumn' Record Flat r -> Restrict (PlaceHolders p)
r

-- | Make typed 'Update' from 'Table' and 'Restrict' computation.
--   Update target is all column.
typedUpdateAllColumn :: PersistableWidth r
                     => Table r
                     -> (Record Flat r -> Restrict (PlaceHolders p))
                     -> Update (r, p)
typedUpdateAllColumn :: Table r
-> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
typedUpdateAllColumn = Config
-> Table r
-> (Record Flat r -> Restrict (PlaceHolders p))
-> Update (r, p)
forall r p.
PersistableWidth r =>
Config
-> Table r
-> (Record Flat r -> Restrict (PlaceHolders p))
-> Update (r, p)
typedUpdateAllColumn' Config
defaultConfig

-- | Make typed 'Update' from 'Config', derived table and 'Restrict' computation.
--   Update target is all column.
updateAllColumn' :: (PersistableWidth r, TableDerivable r)
                 => Config
                 -> (Record Flat r -> Restrict (PlaceHolders p))
                 -> Update (r, p)
updateAllColumn' :: Config
-> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
updateAllColumn' Config
config = Config
-> Table r
-> (Record Flat r -> Restrict (PlaceHolders p))
-> Update (r, p)
forall r p.
PersistableWidth r =>
Config
-> Table r
-> (Record Flat r -> Restrict (PlaceHolders p))
-> Update (r, p)
typedUpdateAllColumn' Config
config Table r
forall r. TableDerivable r => Table r
derivedTable

{-# DEPRECATED derivedUpdateAllColumn' "use `updateAllColumn'` instead of this." #-}
-- | Deprecated. use 'updateAllColumn''.
derivedUpdateAllColumn' :: (PersistableWidth r, TableDerivable r)
                        => Config
                        -> (Record Flat r -> Restrict (PlaceHolders p))
                        -> Update (r, p)
derivedUpdateAllColumn' :: Config
-> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
derivedUpdateAllColumn' = Config
-> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
forall r p.
(PersistableWidth r, TableDerivable r) =>
Config
-> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
updateAllColumn'

-- | Make typed 'Update' from 'defaultConfig', derived table and 'Restrict' computation.
--   Update target is all column.
updateAllColumn :: (PersistableWidth r, TableDerivable r)
                => (Record Flat r -> Restrict (PlaceHolders p))
                -> Update (r, p)
updateAllColumn :: (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
updateAllColumn = Config
-> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
forall r p.
(PersistableWidth r, TableDerivable r) =>
Config
-> (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
updateAllColumn' Config
defaultConfig

-- | Make typed 'Update' from 'defaultConfig', derived table and 'Restrict' computation
--   without placeholder other than target table columns.
--   Update target is all column.
updateAllColumnNoPH :: (PersistableWidth r, TableDerivable r)
                    => (Record Flat r -> Restrict ())
                    -> Update r
updateAllColumnNoPH :: (Record Flat r -> Restrict ()) -> Update r
updateAllColumnNoPH =
  Config
-> Table r
-> (Record Flat r -> Assign r (PlaceHolders r))
-> Update r
forall r p.
Config
-> Table r
-> (Record Flat r -> Assign r (PlaceHolders p))
-> Update p
typedUpdate' Config
defaultConfig Table r
forall r. TableDerivable r => Table r
derivedTable ((Record Flat r -> Assign r (PlaceHolders r)) -> Update r)
-> ((Record Flat r -> Restrict ())
    -> Record Flat r -> Assign r (PlaceHolders r))
-> (Record Flat r -> Restrict ())
-> Update r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((PlaceHolders (r, ()) -> PlaceHolders r)
-> Assignings r Restrict (PlaceHolders (r, ()))
-> Assign r (PlaceHolders r)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap PlaceHolders (r, ()) -> PlaceHolders r
forall (f :: * -> *) e a. ProductIsoEmpty f e => f (a, e) -> f a
peRight (Assignings r Restrict (PlaceHolders (r, ()))
 -> Assign r (PlaceHolders r))
-> (Record Flat r -> Assignings r Restrict (PlaceHolders (r, ())))
-> Record Flat r
-> Assign r (PlaceHolders r)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((Record Flat r -> Assignings r Restrict (PlaceHolders (r, ())))
 -> Record Flat r -> Assign r (PlaceHolders r))
-> ((Record Flat r -> Restrict ())
    -> Record Flat r -> Assignings r Restrict (PlaceHolders (r, ())))
-> (Record Flat r -> Restrict ())
-> Record Flat r
-> Assign r (PlaceHolders r)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Record Flat r -> Restrict (PlaceHolders ()))
-> Record Flat r -> Assignings r Restrict (PlaceHolders (r, ()))
forall r p.
PersistableWidth r =>
(Record Flat r -> Restrict (PlaceHolders p))
-> Record Flat r -> Assign r (PlaceHolders (r, p))
liftTargetAllColumn' ((Record Flat r -> Restrict (PlaceHolders ()))
 -> Record Flat r -> Assignings r Restrict (PlaceHolders (r, ())))
-> ((Record Flat r -> Restrict ())
    -> Record Flat r -> Restrict (PlaceHolders ()))
-> (Record Flat r -> Restrict ())
-> Record Flat r
-> Assignings r Restrict (PlaceHolders (r, ()))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Restrict ()
-> Restrict (PlaceHolders ()) -> Restrict (PlaceHolders ())
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> PlaceHolders () -> Restrict (PlaceHolders ())
forall (m :: * -> *) a. Monad m => a -> m a
return PlaceHolders ()
unitPH) (Restrict () -> Restrict (PlaceHolders ()))
-> (Record Flat r -> Restrict ())
-> Record Flat r
-> Restrict (PlaceHolders ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
.)

{-# DEPRECATED derivedUpdateAllColumn "use `updateAllColumn` instead of this." #-}
-- | Deprecated. use 'updateAllColumn'.
derivedUpdateAllColumn :: (PersistableWidth r, TableDerivable r)
                       => (Record Flat r -> Restrict (PlaceHolders p))
                       -> Update (r, p)
derivedUpdateAllColumn :: (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
derivedUpdateAllColumn = (Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
forall r p.
(PersistableWidth r, TableDerivable r) =>
(Record Flat r -> Restrict (PlaceHolders p)) -> Update (r, p)
updateAllColumn

-- | Show update SQL string
instance Show (Update p) where
  show :: Update p -> String
show = Update p -> String
forall p. Update p -> String
untypeUpdate


-- | Insert type to insert record type 'a'.
data Insert a   =
  Insert
  { Insert a -> String
untypeInsert  :: String
  , Insert a -> Maybe (String, Int)
chunkedInsert :: Maybe (String, Int)
  }

-- | Statement to use chunked insert
untypeChunkInsert :: Insert a -> String
untypeChunkInsert :: Insert a -> String
untypeChunkInsert Insert a
ins = String
-> ((String, Int) -> String) -> Maybe (String, Int) -> String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Insert a -> String
forall a. Insert a -> String
untypeInsert Insert a
ins) (String, Int) -> String
forall a b. (a, b) -> a
fst (Maybe (String, Int) -> String) -> Maybe (String, Int) -> String
forall a b. (a -> b) -> a -> b
$ Insert a -> Maybe (String, Int)
forall a. Insert a -> Maybe (String, Int)
chunkedInsert Insert a
ins

-- | Size to use chunked insert
chunkSizeOfInsert :: Insert a -> Int
chunkSizeOfInsert :: Insert a -> Int
chunkSizeOfInsert = Int -> ((String, Int) -> Int) -> Maybe (String, Int) -> Int
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Int
1 (String, Int) -> Int
forall a b. (a, b) -> b
snd (Maybe (String, Int) -> Int)
-> (Insert a -> Maybe (String, Int)) -> Insert a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Insert a -> Maybe (String, Int)
forall a. Insert a -> Maybe (String, Int)
chunkedInsert

-- | Unsafely make typed 'Insert' from single insert and chunked insert SQL.
unsafeTypedInsert' :: String -> String -> Int -> Insert a
unsafeTypedInsert' :: String -> String -> Int -> Insert a
unsafeTypedInsert' String
s = ((String, Int) -> Insert a) -> String -> Int -> Insert a
forall a b c. ((a, b) -> c) -> a -> b -> c
curry (String -> Maybe (String, Int) -> Insert a
forall a. String -> Maybe (String, Int) -> Insert a
Insert String
s (Maybe (String, Int) -> Insert a)
-> ((String, Int) -> Maybe (String, Int))
-> (String, Int)
-> Insert a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String, Int) -> Maybe (String, Int)
forall a. a -> Maybe a
Just)

-- | Unsafely make typed 'Insert' from single insert SQL.
unsafeTypedInsert :: String -> Insert a
unsafeTypedInsert :: String -> Insert a
unsafeTypedInsert String
s = String -> Maybe (String, Int) -> Insert a
forall a. String -> Maybe (String, Int) -> Insert a
Insert String
s Maybe (String, Int)
forall a. Maybe a
Nothing

-- | Make typed 'Insert' from 'Table' and columns selector 'Pi' with configuration parameter.
typedInsert' :: PersistableWidth r => Config -> Table r -> Pi r r' -> Insert r'
typedInsert' :: Config -> Table r -> Pi r r' -> Insert r'
typedInsert' Config
config Table r
tbl =
  Config -> Table r -> InsertTarget r' r -> Insert r'
forall r p. Config -> Table r -> InsertTarget p r -> Insert p
typedInsertValue' Config
config Table r
tbl (InsertTarget r' r -> Insert r')
-> (Pi r r' -> InsertTarget r' r) -> Pi r r' -> Insert r'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Register r (PlaceHolders r') -> InsertTarget r' r
forall r p. Register r (PlaceHolders p) -> InsertTarget p r
insertTarget' (Register r (PlaceHolders r') -> InsertTarget r' r)
-> (Pi r r' -> Register r (PlaceHolders r'))
-> Pi r r'
-> InsertTarget r' r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pi r r' -> Register r (PlaceHolders r')
forall r r'.
PersistableWidth r =>
Pi r r' -> Register r (PlaceHolders r')
piRegister

{-# DEPRECATED typedInsert "use `typedInsert' defaultConfig` instead of this." #-}
-- | Make typed 'Insert' from 'Table' and columns selector 'Pi'.
typedInsert :: PersistableWidth r => Table r -> Pi r r' -> Insert r'
typedInsert :: Table r -> Pi r r' -> Insert r'
typedInsert =  Config -> Table r -> Pi r r' -> Insert r'
forall r r'.
PersistableWidth r =>
Config -> Table r -> Pi r r' -> Insert r'
typedInsert' Config
defaultConfig

-- | Table type inferred 'Insert'.
insert :: (PersistableWidth r, TableDerivable r) => Pi r r' -> Insert r'
insert :: Pi r r' -> Insert r'
insert = Config -> Table r -> Pi r r' -> Insert r'
forall r r'.
PersistableWidth r =>
Config -> Table r -> Pi r r' -> Insert r'
typedInsert' Config
defaultConfig Table r
forall r. TableDerivable r => Table r
derivedTable

{-# DEPRECATED derivedInsert "use `insert` instead of this." #-}
-- | Table type inferred 'Insert'.
derivedInsert :: (PersistableWidth r, TableDerivable r) => Pi r r' -> Insert r'
derivedInsert :: Pi r r' -> Insert r'
derivedInsert = Pi r r' -> Insert r'
forall r r'.
(PersistableWidth r, TableDerivable r) =>
Pi r r' -> Insert r'
insert

-- | Make typed 'Insert' from 'Config', 'Table' and monadic builded 'InsertTarget' object.
typedInsertValue' :: Config -> Table r -> InsertTarget p r -> Insert p
typedInsertValue' :: Config -> Table r -> InsertTarget p r -> Insert p
typedInsertValue' Config
config Table r
tbl InsertTarget p r
it =
    String -> String -> Int -> Insert p
forall a. String -> String -> Int -> Insert a
unsafeTypedInsert'
    (StringSQL -> String
showStringSQL (StringSQL -> String) -> StringSQL -> String
forall a b. (a -> b) -> a -> b
$ Config -> Table r -> InsertTarget p r -> StringSQL
forall r p. Config -> Table r -> InsertTarget p r -> StringSQL
sqlFromInsertTarget Config
config Table r
tbl InsertTarget p r
it)
    (StringSQL -> String
showStringSQL StringSQL
ci) Int
n
  where
    (StringSQL
ci, Int
n) = Config -> Table r -> InsertTarget p r -> (StringSQL, Int)
forall r p.
Config -> Table r -> InsertTarget p r -> (StringSQL, Int)
sqlChunkFromInsertTarget Config
config Table r
tbl InsertTarget p r
it

{-# DEPRECATED typedInsertValue "use `typedInsertValue' defaultConfig` instead of this." #-}
-- | Make typed 'Insert' from 'Table' and monadic builded 'InsertTarget' object.
typedInsertValue :: Table r -> InsertTarget p r -> Insert p
typedInsertValue :: Table r -> InsertTarget p r -> Insert p
typedInsertValue = Config -> Table r -> InsertTarget p r -> Insert p
forall r p. Config -> Table r -> InsertTarget p r -> Insert p
typedInsertValue' Config
defaultConfig

-- | Make typed 'Insert' from 'Config', derived table and monadic builded 'Register' object.
insertValue' :: TableDerivable r => Config -> Register r (PlaceHolders p) -> Insert p
insertValue' :: Config -> Register r (PlaceHolders p) -> Insert p
insertValue' Config
config Register r (PlaceHolders p)
rs = Config -> Table r -> InsertTarget p r -> Insert p
forall r p. Config -> Table r -> InsertTarget p r -> Insert p
typedInsertValue' Config
config (Register r (PlaceHolders p) -> Table r
forall r p.
TableDerivable r =>
Register r (PlaceHolders p) -> Table r
rt Register r (PlaceHolders p)
rs) (InsertTarget p r -> Insert p) -> InsertTarget p r -> Insert p
forall a b. (a -> b) -> a -> b
$ Register r (PlaceHolders p) -> InsertTarget p r
forall r p. Register r (PlaceHolders p) -> InsertTarget p r
insertTarget' Register r (PlaceHolders p)
rs
  where
    rt :: TableDerivable r => Register r (PlaceHolders p) -> Table r
    rt :: Register r (PlaceHolders p) -> Table r
rt =  Table r -> Register r (PlaceHolders p) -> Table r
forall a b. a -> b -> a
const Table r
forall r. TableDerivable r => Table r
derivedTable

{-# DEPRECATED derivedInsertValue' "use `insertValue'` instead of this." #-}
-- | Make typed 'Insert' from 'Config', derived table and monadic builded 'Register' object.
derivedInsertValue' :: TableDerivable r => Config -> Register r (PlaceHolders p) -> Insert p
derivedInsertValue' :: Config -> Register r (PlaceHolders p) -> Insert p
derivedInsertValue' = Config -> Register r (PlaceHolders p) -> Insert p
forall r p.
TableDerivable r =>
Config -> Register r (PlaceHolders p) -> Insert p
insertValue'

-- | Make typed 'Insert' from 'defaultConfig', derived table and monadic builded 'Register' object.
insertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p
insertValue :: Register r (PlaceHolders p) -> Insert p
insertValue = Config -> Register r (PlaceHolders p) -> Insert p
forall r p.
TableDerivable r =>
Config -> Register r (PlaceHolders p) -> Insert p
insertValue' Config
defaultConfig

-- | Make typed 'Insert' from 'defaultConfig', derived table and monadic builded 'Register' object with no(unit) placeholder.
insertValueNoPH :: TableDerivable r => Register r () -> Insert ()
insertValueNoPH :: Register r () -> Insert ()
insertValueNoPH = Register r (PlaceHolders ()) -> Insert ()
forall r p.
TableDerivable r =>
Register r (PlaceHolders p) -> Insert p
insertValue (Register r (PlaceHolders ()) -> Insert ())
-> (Register r () -> Register r (PlaceHolders ()))
-> Register r ()
-> Insert ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Register r ()
-> Register r (PlaceHolders ()) -> Register r (PlaceHolders ())
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> PlaceHolders () -> Register r (PlaceHolders ())
forall (m :: * -> *) a. Monad m => a -> m a
return PlaceHolders ()
unitPH)

{-# DEPRECATED derivedInsertValue "use `insertValue` instead of this." #-}
-- | Make typed 'Insert' from 'defaultConfig', derived table and monadic builded 'Register' object.
derivedInsertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p
derivedInsertValue :: Register r (PlaceHolders p) -> Insert p
derivedInsertValue = Register r (PlaceHolders p) -> Insert p
forall r p.
TableDerivable r =>
Register r (PlaceHolders p) -> Insert p
insertValue

-- | Make typed 'Insert' list from 'Config' and records list.
insertValueList' :: (TableDerivable r, LiteralSQL r')
                 => Config
                 -> Pi r r'
                 -> [r']
                 -> [Insert ()]
insertValueList' :: Config -> Pi r r' -> [r'] -> [Insert ()]
insertValueList' Config
config Pi r r'
pi' =
  (StringSQL -> Insert ()) -> QuerySuffix -> [Insert ()]
forall a b. (a -> b) -> [a] -> [b]
map (String -> Insert ()
forall a. String -> Insert a
unsafeTypedInsert (String -> Insert ())
-> (StringSQL -> String) -> StringSQL -> Insert ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StringSQL -> String
showStringSQL)
  (QuerySuffix -> [Insert ()])
-> ([r'] -> QuerySuffix) -> [r'] -> [Insert ()]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Config -> Table r -> Pi r r' -> [r'] -> QuerySuffix
forall r' r.
LiteralSQL r' =>
Config -> Table r -> Pi r r' -> [r'] -> QuerySuffix
sqlChunksFromRecordList Config
config Table r
forall r. TableDerivable r => Table r
derivedTable Pi r r'
pi'

-- | Make typed 'Insert' list from records list.
insertValueList :: (TableDerivable r, LiteralSQL r')
                => Pi r r'
                -> [r']
                -> [Insert ()]
insertValueList :: Pi r r' -> [r'] -> [Insert ()]
insertValueList = Config -> Pi r r' -> [r'] -> [Insert ()]
forall r r'.
(TableDerivable r, LiteralSQL r') =>
Config -> Pi r r' -> [r'] -> [Insert ()]
insertValueList' Config
defaultConfig

-- | Show insert SQL string.
instance Show (Insert a) where
  show :: Insert a -> String
show = Insert a -> String
forall a. Insert a -> String
untypeInsert

-- | InsertQuery type.
newtype InsertQuery p = InsertQuery { InsertQuery p -> String
untypeInsertQuery :: String }

-- | Unsafely make typed 'InsertQuery' from SQL string.
unsafeTypedInsertQuery :: String -> InsertQuery p
unsafeTypedInsertQuery :: String -> InsertQuery p
unsafeTypedInsertQuery =  String -> InsertQuery p
forall p. String -> InsertQuery p
InsertQuery

-- | Make untyped insert select SQL string from 'Table', 'Pi' and 'Relation'.
insertQuerySQL :: Config -> Table r -> Pi r r' -> Relation p r' -> String
insertQuerySQL :: Config -> Table r -> Pi r r' -> Relation p r' -> String
insertQuerySQL Config
config Table r
tbl Pi r r'
pi' Relation p r'
rel = StringSQL -> String
showStringSQL (StringSQL -> String) -> StringSQL -> String
forall a b. (a -> b) -> a -> b
$ Pi r r' -> Table r -> StringSQL
forall r r'. Pi r r' -> Table r -> StringSQL
insertPrefixSQL Pi r r'
pi' Table r
tbl StringSQL -> StringSQL -> StringSQL
forall a. Semigroup a => a -> a -> a
<> Relation p r' -> Config -> StringSQL
forall p r. Relation p r -> Config -> StringSQL
sqlFromRelationWith Relation p r'
rel Config
config

-- | Make typed 'InsertQuery' from columns selector 'Table', 'Pi' and 'Relation' with configuration parameter.
typedInsertQuery' :: Config -> Table r -> Pi r r' -> Relation p r' -> InsertQuery p
typedInsertQuery' :: Config -> Table r -> Pi r r' -> Relation p r' -> InsertQuery p
typedInsertQuery' Config
config Table r
tbl Pi r r'
pi' Relation p r'
rel = String -> InsertQuery p
forall p. String -> InsertQuery p
unsafeTypedInsertQuery (String -> InsertQuery p) -> String -> InsertQuery p
forall a b. (a -> b) -> a -> b
$ Config -> Table r -> Pi r r' -> Relation p r' -> String
forall r r' p.
Config -> Table r -> Pi r r' -> Relation p r' -> String
insertQuerySQL Config
config Table r
tbl Pi r r'
pi' Relation p r'
rel

{-# DEPRECATED typedInsertQuery "use `typedInsertQuery' defaultConfig` instead of this." #-}
-- | Make typed 'InsertQuery' from columns selector 'Table', 'Pi' and 'Relation'.
typedInsertQuery :: Table r -> Pi r r' -> Relation p r' -> InsertQuery p
typedInsertQuery :: Table r -> Pi r r' -> Relation p r' -> InsertQuery p
typedInsertQuery =  Config -> Table r -> Pi r r' -> Relation p r' -> InsertQuery p
forall r r' p.
Config -> Table r -> Pi r r' -> Relation p r' -> InsertQuery p
typedInsertQuery' Config
defaultConfig

-- | Table type inferred 'InsertQuery'.
insertQuery' :: TableDerivable r => Config -> Pi r r' -> Relation p r' -> InsertQuery p
insertQuery' :: Config -> Pi r r' -> Relation p r' -> InsertQuery p
insertQuery' Config
config = Config -> Table r -> Pi r r' -> Relation p r' -> InsertQuery p
forall r r' p.
Config -> Table r -> Pi r r' -> Relation p r' -> InsertQuery p
typedInsertQuery' Config
config Table r
forall r. TableDerivable r => Table r
derivedTable

-- | Table type inferred 'InsertQuery' with 'defaultConfig'.
insertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p
insertQuery :: Pi r r' -> Relation p r' -> InsertQuery p
insertQuery = Config -> Pi r r' -> Relation p r' -> InsertQuery p
forall r r' p.
TableDerivable r =>
Config -> Pi r r' -> Relation p r' -> InsertQuery p
insertQuery' Config
defaultConfig

{-# DEPRECATED derivedInsertQuery "use `insertQuery` instead of this." #-}
-- | Table type inferred 'InsertQuery'.
derivedInsertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p
derivedInsertQuery :: Pi r r' -> Relation p r' -> InsertQuery p
derivedInsertQuery = Pi r r' -> Relation p r' -> InsertQuery p
forall r r' p.
TableDerivable r =>
Pi r r' -> Relation p r' -> InsertQuery p
insertQuery

-- | Show insert SQL string.
instance Show (InsertQuery p) where
  show :: InsertQuery p -> String
show = InsertQuery p -> String
forall p. InsertQuery p -> String
untypeInsertQuery


-- | Delete type with place-holder parameter 'p'.
newtype Delete p = Delete { Delete p -> String
untypeDelete :: String }

-- | Unsafely make typed 'Delete' from SQL string.
unsafeTypedDelete :: String -> Delete p
unsafeTypedDelete :: String -> Delete p
unsafeTypedDelete =  String -> Delete p
forall p. String -> Delete p
Delete

-- | Make untyped delete SQL string from 'Table' and 'Restrict' computation.
deleteSQL :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> String
deleteSQL :: Config
-> Table r
-> (Record Flat r -> Restrict (PlaceHolders p))
-> String
deleteSQL Config
config Table r
tbl Record Flat r -> Restrict (PlaceHolders p)
r = StringSQL -> String
showStringSQL (StringSQL -> String) -> StringSQL -> String
forall a b. (a -> b) -> a -> b
$ Config
-> Table r
-> (Record Flat r -> Restrict (PlaceHolders p))
-> StringSQL
forall r p.
Config
-> Table r
-> (Record Flat r -> Restrict (PlaceHolders p))
-> StringSQL
deleteFromRestriction Config
config Table r
tbl Record Flat r -> Restrict (PlaceHolders p)
r

-- | Make typed 'Delete' from 'Config', 'Table' and 'Restrict' computation.
typedDelete' :: Config -> Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
typedDelete' :: Config
-> Table r
-> (Record Flat r -> Restrict (PlaceHolders p))
-> Delete p
typedDelete' Config
config Table r
tbl Record Flat r -> Restrict (PlaceHolders p)
r = String -> Delete p
forall p. String -> Delete p
unsafeTypedDelete (String -> Delete p) -> String -> Delete p
forall a b. (a -> b) -> a -> b
$ Config
-> Table r
-> (Record Flat r -> Restrict (PlaceHolders p))
-> String
forall r p.
Config
-> Table r
-> (Record Flat r -> Restrict (PlaceHolders p))
-> String
deleteSQL Config
config Table r
tbl Record Flat r -> Restrict (PlaceHolders p)
r

{-# DEPRECATED typedDelete "use `typedDelete' defaultConfig` instead of this." #-}
-- | Make typed 'Delete' from 'Table' and 'Restrict' computation.
typedDelete :: Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
typedDelete :: Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
typedDelete =  Config
-> Table r
-> (Record Flat r -> Restrict (PlaceHolders p))
-> Delete p
forall r p.
Config
-> Table r
-> (Record Flat r -> Restrict (PlaceHolders p))
-> Delete p
typedDelete' Config
defaultConfig

restrictedTable :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Table r
restrictedTable :: (Record Flat r -> Restrict (PlaceHolders p)) -> Table r
restrictedTable =  Table r -> (Record Flat r -> Restrict (PlaceHolders p)) -> Table r
forall a b. a -> b -> a
const Table r
forall r. TableDerivable r => Table r
derivedTable

-- | Make typed 'Delete' from 'Config', derived table and 'Restrict' computation.
delete' :: TableDerivable r => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
delete' :: Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
delete' Config
config Record Flat r -> Restrict (PlaceHolders p)
rc = Config
-> Table r
-> (Record Flat r -> Restrict (PlaceHolders p))
-> Delete p
forall r p.
Config
-> Table r
-> (Record Flat r -> Restrict (PlaceHolders p))
-> Delete p
typedDelete' Config
config ((Record Flat r -> Restrict (PlaceHolders p)) -> Table r
forall r p.
TableDerivable r =>
(Record Flat r -> Restrict (PlaceHolders p)) -> Table r
restrictedTable Record Flat r -> Restrict (PlaceHolders p)
rc) Record Flat r -> Restrict (PlaceHolders p)
rc

{-# DEPRECATED derivedDelete' "use `delete'` instead of this." #-}
-- | Make typed 'Delete' from 'Config', derived table and 'Restrict' computation.
derivedDelete' :: TableDerivable r => Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
derivedDelete' :: Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
derivedDelete' = Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
forall r p.
TableDerivable r =>
Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
delete'

-- | Make typed 'Delete' from 'defaultConfig', derived table and 'Restrict' computation.
delete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
delete :: (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
delete = Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
forall r p.
TableDerivable r =>
Config -> (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
delete' Config
defaultConfig

-- | Make typed 'Delete' from 'defaultConfig', derived table and 'Restrict' computation with no(unit) placeholder.
deleteNoPH :: TableDerivable r => (Record Flat r -> Restrict ()) -> Delete ()
deleteNoPH :: (Record Flat r -> Restrict ()) -> Delete ()
deleteNoPH Record Flat r -> Restrict ()
rf = (Record Flat r -> Restrict (PlaceHolders ())) -> Delete ()
forall r p.
TableDerivable r =>
(Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
delete ((Record Flat r -> Restrict (PlaceHolders ())) -> Delete ())
-> (Record Flat r -> Restrict (PlaceHolders ())) -> Delete ()
forall a b. (a -> b) -> a -> b
$ (Restrict ()
-> Restrict (PlaceHolders ()) -> Restrict (PlaceHolders ())
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> PlaceHolders () -> Restrict (PlaceHolders ())
forall (m :: * -> *) a. Monad m => a -> m a
return PlaceHolders ()
unitPH) (Restrict () -> Restrict (PlaceHolders ()))
-> (Record Flat r -> Restrict ())
-> Record Flat r
-> Restrict (PlaceHolders ())
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Record Flat r -> Restrict ()
rf

{-# DEPRECATED derivedDelete "use `delete` instead of this." #-}
-- | Make typed 'Delete' from 'defaultConfig', derived table and 'Restrict' computation.
derivedDelete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
derivedDelete :: (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
derivedDelete = (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
forall r p.
TableDerivable r =>
(Record Flat r -> Restrict (PlaceHolders p)) -> Delete p
delete

-- | Show delete SQL string
instance Show (Delete p) where
  show :: Delete p -> String
show = Delete p -> String
forall p. Delete p -> String
untypeDelete


-- | Untype interface for typed no-result type statments
--   with single type parameter which represents place-holder parameter 'p'.
class UntypeableNoFetch s where
  untypeNoFetch :: s p -> String

instance UntypeableNoFetch Insert where
  untypeNoFetch :: Insert p -> String
untypeNoFetch = Insert p -> String
forall a. Insert a -> String
untypeInsert

instance UntypeableNoFetch InsertQuery where
  untypeNoFetch :: InsertQuery p -> String
untypeNoFetch = InsertQuery p -> String
forall p. InsertQuery p -> String
untypeInsertQuery

instance UntypeableNoFetch Update where
  untypeNoFetch :: Update p -> String
untypeNoFetch = Update p -> String
forall p. Update p -> String
untypeUpdate

instance UntypeableNoFetch Delete where
  untypeNoFetch :: Delete p -> String
untypeNoFetch = Delete p -> String
forall p. Delete p -> String
untypeDelete