{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE GADTs                 #-}
{-# LANGUAGE MultiParamTypeClasses #-}

module Opaleye.Internal.Manipulation where

import qualified Control.Applicative as A

import           Opaleye.Internal.Column (Field_(Column), Field)
import qualified Opaleye.Internal.HaskellDB.Sql  as HSql
import qualified Opaleye.Internal.HaskellDB.Sql.Default  as SD
import qualified Opaleye.Internal.HaskellDB.Sql.Generate as SG
import qualified Opaleye.Internal.HaskellDB.Sql.Print    as HPrint
import           Opaleye.Internal.Helpers        ((.:), (.:.), (.::.), (.::))
import qualified Opaleye.Internal.PrimQuery      as PQ
import qualified Opaleye.Internal.Print          as Print
import qualified Opaleye.Internal.RunQuery       as IRQ
import qualified Opaleye.RunSelect               as RS
import qualified Opaleye.Internal.Sql            as Sql
import qualified Opaleye.Internal.Table          as TI
import qualified Opaleye.Internal.Unpackspec     as U
import qualified Opaleye.Table                   as T
import           Opaleye.SqlTypes (SqlBool)

import           Data.Int                       (Int64)
import qualified Data.List.NonEmpty              as NEL
import           Data.Profunctor                 (Profunctor, dimap)
import qualified Data.Profunctor.Product         as PP
import qualified Data.Profunctor.Product.Default as D
import           Data.String                     (fromString)

import qualified Database.PostgreSQL.Simple as PGS

-- | Represents a @RETURNING@ statement for a manipulation query.
data Returning fields haskells where
  Count
    :: Returning a Int64
  ReturningExplicit
    :: RS.FromFields b c -> (a -> b) -> Returning a [c]

arrangeInsertMany :: T.Table columns a
                  -> NEL.NonEmpty columns
                  -> Maybe HSql.OnConflict
                  -> HSql.SqlInsert
arrangeInsertMany :: forall columns a.
Table columns a
-> NonEmpty columns -> Maybe OnConflict -> SqlInsert
arrangeInsertMany Table columns a
table NonEmpty columns
columns Maybe OnConflict
onConflict = SqlInsert
insert
  where writer :: Writer columns a
writer = forall writeColumns viewColumns.
TableFields writeColumns viewColumns
-> Writer writeColumns viewColumns
TI.tableColumnsWriter (forall writeColumns viewColumns.
Table writeColumns viewColumns
-> TableFields writeColumns viewColumns
TI.tableColumns Table columns a
table)
        (NonEmpty [PrimExpr]
columnExprs, [String]
columnNames) = forall columns columns'.
Writer columns columns'
-> NonEmpty columns -> (NonEmpty [PrimExpr], [String])
TI.runWriter' Writer columns a
writer NonEmpty columns
columns
        insert :: SqlInsert
insert = SqlGenerator
-> SqlTable
-> [String]
-> NonEmpty [PrimExpr]
-> Maybe OnConflict
-> SqlInsert
SG.sqlInsert SqlGenerator
SD.defaultSqlGenerator
                      (TableIdentifier -> SqlTable
PQ.tiToSqlTable (forall writeColumns viewColumns.
Table writeColumns viewColumns -> TableIdentifier
TI.tableIdentifier Table columns a
table))
                      [String]
columnNames NonEmpty [PrimExpr]
columnExprs
                      Maybe OnConflict
onConflict

arrangeInsertManyReturning :: U.Unpackspec columnsReturned ignored
                           -> T.Table columnsW columnsR
                           -> NEL.NonEmpty columnsW
                           -> (columnsR -> columnsReturned)
                           -> Maybe HSql.OnConflict
                           -> Sql.Returning HSql.SqlInsert
arrangeInsertManyReturning :: forall columnsReturned ignored columnsW columnsR.
Unpackspec columnsReturned ignored
-> Table columnsW columnsR
-> NonEmpty columnsW
-> (columnsR -> columnsReturned)
-> Maybe OnConflict
-> Returning SqlInsert
arrangeInsertManyReturning Unpackspec columnsReturned ignored
unpackspec Table columnsW columnsR
table NonEmpty columnsW
columns columnsR -> columnsReturned
returningf Maybe OnConflict
onConflict =
  forall a. a -> NonEmpty SqlExpr -> Returning a
Sql.Returning SqlInsert
insert NonEmpty SqlExpr
returningSEs
  where insert :: SqlInsert
insert = forall columns a.
Table columns a
-> NonEmpty columns -> Maybe OnConflict -> SqlInsert
arrangeInsertMany Table columnsW columnsR
table NonEmpty columnsW
columns Maybe OnConflict
onConflict
        TI.View columnsR
columnsR = forall writeColumns viewColumns.
TableFields writeColumns viewColumns -> View viewColumns
TI.tableColumnsView (forall writeColumns viewColumns.
Table writeColumns viewColumns
-> TableFields writeColumns viewColumns
TI.tableColumns Table columnsW columnsR
table)
        returningPEs :: [PrimExpr]
returningPEs = forall s t. Unpackspec s t -> s -> [PrimExpr]
U.collectPEs Unpackspec columnsReturned ignored
unpackspec (columnsR -> columnsReturned
returningf columnsR
columnsR)
        returningSEs :: NonEmpty SqlExpr
returningSEs = forall a. (SqlExpr -> a) -> [a] -> NonEmpty a
Sql.ensureColumnsGen forall a. a -> a
id (forall a b. (a -> b) -> [a] -> [b]
map PrimExpr -> SqlExpr
Sql.sqlExpr [PrimExpr]
returningPEs)

arrangeInsertManyReturningSql :: U.Unpackspec columnsReturned ignored
                              -> T.Table columnsW columnsR
                              -> NEL.NonEmpty columnsW
                              -> (columnsR -> columnsReturned)
                              -> Maybe HSql.OnConflict
                              -> String
arrangeInsertManyReturningSql :: forall columnsReturned ignored columnsW columnsR.
Unpackspec columnsReturned ignored
-> Table columnsW columnsR
-> NonEmpty columnsW
-> (columnsR -> columnsReturned)
-> Maybe OnConflict
-> String
arrangeInsertManyReturningSql =
  forall a. Show a => a -> String
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. Returning SqlInsert -> Doc
Print.ppInsertReturning forall r z a b c d e.
(r -> z)
-> (a -> b -> c -> d -> e -> r) -> a -> b -> c -> d -> e -> z
.::. forall columnsReturned ignored columnsW columnsR.
Unpackspec columnsReturned ignored
-> Table columnsW columnsR
-> NonEmpty columnsW
-> (columnsR -> columnsReturned)
-> Maybe OnConflict
-> Returning SqlInsert
arrangeInsertManyReturning

arrangeInsertManySql :: T.Table columnsW columnsR
                     -> NEL.NonEmpty columnsW
                     -> Maybe HSql.OnConflict
                     -> String
arrangeInsertManySql :: forall columnsW columnsR.
Table columnsW columnsR
-> NonEmpty columnsW -> Maybe OnConflict -> String
arrangeInsertManySql =
  forall a. Show a => a -> String
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqlInsert -> Doc
HPrint.ppInsert forall r z a b c.
(r -> z) -> (a -> b -> c -> r) -> a -> b -> c -> z
.:. forall columns a.
Table columns a
-> NonEmpty columns -> Maybe OnConflict -> SqlInsert
arrangeInsertMany

runInsertManyReturningExplicit
  :: RS.FromFields columnsReturned haskells
  -> PGS.Connection
  -> T.Table columnsW columnsR
  -> [columnsW]
  -> (columnsR -> columnsReturned)
  -> Maybe HSql.OnConflict
  -> IO [haskells]
runInsertManyReturningExplicit :: forall columnsReturned haskells columnsW columnsR.
FromFields columnsReturned haskells
-> Connection
-> Table columnsW columnsR
-> [columnsW]
-> (columnsR -> columnsReturned)
-> Maybe OnConflict
-> IO [haskells]
runInsertManyReturningExplicit
  FromFields columnsReturned haskells
qr Connection
conn Table columnsW columnsR
t [columnsW]
columns columnsR -> columnsReturned
r Maybe OnConflict
onConflict =
  case forall a. [a] -> Maybe (NonEmpty a)
NEL.nonEmpty [columnsW]
columns of
    Maybe (NonEmpty columnsW)
Nothing       -> forall (m :: * -> *) a. Monad m => a -> m a
return []
    Just NonEmpty columnsW
columns' -> forall r. RowParser r -> Connection -> Query -> IO [r]
PGS.queryWith_ RowParser haskells
parser Connection
conn
                       (forall a. IsString a => String -> a
fromString
                        (forall columnsReturned ignored columnsW columnsR.
Unpackspec columnsReturned ignored
-> Table columnsW columnsR
-> NonEmpty columnsW
-> (columnsR -> columnsReturned)
-> Maybe OnConflict
-> String
arrangeInsertManyReturningSql Unpackspec columnsReturned ()
u Table columnsW columnsR
t NonEmpty columnsW
columns' columnsR -> columnsReturned
r
                                                       Maybe OnConflict
onConflict))
  where IRQ.FromFields Unpackspec columnsReturned ()
u columnsReturned -> RowParser haskells
_ columnsReturned -> Int
_ = FromFields columnsReturned haskells
qr
        parser :: RowParser haskells
parser = forall columns haskells.
FromFields columns haskells -> columns -> RowParser haskells
IRQ.prepareRowParser FromFields columnsReturned haskells
qr (columnsR -> columnsReturned
r columnsR
v)
        TI.View columnsR
v = forall writeColumns viewColumns.
TableFields writeColumns viewColumns -> View viewColumns
TI.tableColumnsView (forall writeColumns viewColumns.
Table writeColumns viewColumns
-> TableFields writeColumns viewColumns
TI.tableColumns Table columnsW columnsR
t)
        -- This method of getting hold of the return type feels a bit
        -- suspect.  I haven't checked it for validity.

newtype Updater a b = Updater (a -> b)

-- { Boilerplate instances

instance Functor (Updater a) where
  fmap :: forall a b. (a -> b) -> Updater a a -> Updater a b
fmap a -> b
f (Updater a -> a
g) = forall a b. (a -> b) -> Updater a b
Updater (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f a -> a
g)

instance A.Applicative (Updater a) where
  pure :: forall a. a -> Updater a a
pure = forall a b. (a -> b) -> Updater a b
Updater forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
A.pure
  Updater a -> a -> b
f <*> :: forall a b. Updater a (a -> b) -> Updater a a -> Updater a b
<*> Updater a -> a
x = forall a b. (a -> b) -> Updater a b
Updater (a -> a -> b
f forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
A.<*> a -> a
x)

instance Profunctor Updater where
  dimap :: forall a b c d. (a -> b) -> (c -> d) -> Updater b c -> Updater a d
dimap a -> b
f c -> d
g (Updater b -> c
h) = forall a b. (a -> b) -> Updater a b
Updater (forall (p :: * -> * -> *) a b c d.
Profunctor p =>
(a -> b) -> (c -> d) -> p b c -> p a d
dimap a -> b
f c -> d
g b -> c
h)

instance PP.ProductProfunctor Updater where
  purePP :: forall b a. b -> Updater a b
purePP = forall (f :: * -> *) a. Applicative f => a -> f a
pure
  **** :: forall a a b. Updater a (a -> b) -> Updater a a -> Updater a b
(****) = forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
(<*>)

--

instance D.Default Updater (Field_ n a) (Field_ n a) where
  def :: Updater (Field_ n a) (Field_ n a)
def = forall a b. (a -> b) -> Updater a b
Updater forall a. a -> a
id

instance D.Default Updater (Field_ n a) (Maybe (Field_ n a)) where
  def :: Updater (Field_ n a) (Maybe (Field_ n a))
def = forall a b. (a -> b) -> Updater a b
Updater forall a. a -> Maybe a
Just

arrangeDeleteReturning :: U.Unpackspec columnsReturned ignored
                       -> T.Table columnsW columnsR
                       -> (columnsR -> Field SqlBool)
                       -> (columnsR -> columnsReturned)
                       -> Sql.Returning HSql.SqlDelete
  -- this implementation was copied, it does not make sense yet
arrangeDeleteReturning :: forall columnsReturned ignored columnsW columnsR.
Unpackspec columnsReturned ignored
-> Table columnsW columnsR
-> (columnsR -> Field SqlBool)
-> (columnsR -> columnsReturned)
-> Returning SqlDelete
arrangeDeleteReturning Unpackspec columnsReturned ignored
unpackspec Table columnsW columnsR
t columnsR -> Field SqlBool
cond columnsR -> columnsReturned
returningf =
  forall a. a -> NonEmpty SqlExpr -> Returning a
Sql.Returning SqlDelete
delete NonEmpty SqlExpr
returningSEs
  where delete :: SqlDelete
delete = forall a columnsR.
Table a columnsR -> (columnsR -> Field SqlBool) -> SqlDelete
arrangeDelete Table columnsW columnsR
t columnsR -> Field SqlBool
cond
        TI.View columnsR
columnsR = forall writeColumns viewColumns.
TableFields writeColumns viewColumns -> View viewColumns
TI.tableColumnsView (forall writeColumns viewColumns.
Table writeColumns viewColumns
-> TableFields writeColumns viewColumns
TI.tableColumns Table columnsW columnsR
t)
        returningPEs :: [PrimExpr]
returningPEs = forall s t. Unpackspec s t -> s -> [PrimExpr]
U.collectPEs Unpackspec columnsReturned ignored
unpackspec (columnsR -> columnsReturned
returningf columnsR
columnsR)
        returningSEs :: NonEmpty SqlExpr
returningSEs = forall a. (SqlExpr -> a) -> [a] -> NonEmpty a
Sql.ensureColumnsGen forall a. a -> a
id (forall a b. (a -> b) -> [a] -> [b]
map PrimExpr -> SqlExpr
Sql.sqlExpr [PrimExpr]
returningPEs)

arrangeDeleteReturningSql :: U.Unpackspec columnsReturned ignored
                          -> T.Table columnsW columnsR
                          -> (columnsR -> Field SqlBool)
                          -> (columnsR -> columnsReturned)
                          -> String
arrangeDeleteReturningSql :: forall columnsReturned ignored columnsW columnsR.
Unpackspec columnsReturned ignored
-> Table columnsW columnsR
-> (columnsR -> Field SqlBool)
-> (columnsR -> columnsReturned)
-> String
arrangeDeleteReturningSql =
  forall a. Show a => a -> String
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. Returning SqlDelete -> Doc
Print.ppDeleteReturning forall r z a b c d.
(r -> z) -> (a -> b -> c -> d -> r) -> a -> b -> c -> d -> z
.:: forall columnsReturned ignored columnsW columnsR.
Unpackspec columnsReturned ignored
-> Table columnsW columnsR
-> (columnsR -> Field SqlBool)
-> (columnsR -> columnsReturned)
-> Returning SqlDelete
arrangeDeleteReturning


runDeleteReturning :: (D.Default RS.FromFields columnsReturned haskells)
                   => PGS.Connection
                   -- ^
                   -> T.Table a columnsR
                   -- ^ Table to delete rows from
                   -> (columnsR -> Field SqlBool)
                   -- ^ Predicate function @f@ to choose which rows to delete.
                   -- 'runDeleteReturning' will delete rows for which @f@ returns @TRUE@
                   -- and leave unchanged rows for
                   -- which @f@ returns @FALSE@.
                   -> (columnsR -> columnsReturned)
                   -> IO [haskells]
                   -- ^ Returned rows which have been deleted
runDeleteReturning :: forall columnsReturned haskells a columnsR.
Default FromFields columnsReturned haskells =>
Connection
-> Table a columnsR
-> (columnsR -> Field SqlBool)
-> (columnsR -> columnsReturned)
-> IO [haskells]
runDeleteReturning = forall columnsReturned haskells a columnsR.
FromFields columnsReturned haskells
-> Connection
-> Table a columnsR
-> (columnsR -> Field SqlBool)
-> (columnsR -> columnsReturned)
-> IO [haskells]
runDeleteReturningExplicit forall (p :: * -> * -> *) a b. Default p a b => p a b
D.def

runDeleteReturningExplicit :: RS.FromFields columnsReturned haskells
                           -> PGS.Connection
                           -> T.Table a columnsR
                           -> (columnsR -> Field SqlBool)
                           -> (columnsR -> columnsReturned)
                           -> IO [haskells]
runDeleteReturningExplicit :: forall columnsReturned haskells a columnsR.
FromFields columnsReturned haskells
-> Connection
-> Table a columnsR
-> (columnsR -> Field SqlBool)
-> (columnsR -> columnsReturned)
-> IO [haskells]
runDeleteReturningExplicit FromFields columnsReturned haskells
qr Connection
conn Table a columnsR
t columnsR -> Field SqlBool
cond columnsR -> columnsReturned
r =
  forall r. RowParser r -> Connection -> Query -> IO [r]
PGS.queryWith_ RowParser haskells
parser Connection
conn
                 (forall a. IsString a => String -> a
fromString (forall columnsReturned ignored columnsW columnsR.
Unpackspec columnsReturned ignored
-> Table columnsW columnsR
-> (columnsR -> Field SqlBool)
-> (columnsR -> columnsReturned)
-> String
arrangeDeleteReturningSql Unpackspec columnsReturned ()
u Table a columnsR
t columnsR -> Field SqlBool
cond columnsR -> columnsReturned
r))
  where IRQ.FromFields Unpackspec columnsReturned ()
u columnsReturned -> RowParser haskells
_ columnsReturned -> Int
_ = FromFields columnsReturned haskells
qr
        parser :: RowParser haskells
parser = forall columns haskells.
FromFields columns haskells -> columns -> RowParser haskells
IRQ.prepareRowParser FromFields columnsReturned haskells
qr (columnsR -> columnsReturned
r columnsR
v)
        TI.View columnsR
v = forall writeColumns viewColumns.
TableFields writeColumns viewColumns -> View viewColumns
TI.tableColumnsView (forall writeColumns viewColumns.
Table writeColumns viewColumns
-> TableFields writeColumns viewColumns
TI.tableColumns Table a columnsR
t)

arrangeDelete :: T.Table a columnsR -> (columnsR -> Field SqlBool) -> HSql.SqlDelete
arrangeDelete :: forall a columnsR.
Table a columnsR -> (columnsR -> Field SqlBool) -> SqlDelete
arrangeDelete Table a columnsR
t columnsR -> Field SqlBool
cond =
  SqlGenerator -> SqlTable -> [PrimExpr] -> SqlDelete
SG.sqlDelete SqlGenerator
SD.defaultSqlGenerator (TableIdentifier -> SqlTable
PQ.tiToSqlTable (forall writeColumns viewColumns.
Table writeColumns viewColumns -> TableIdentifier
TI.tableIdentifier Table a columnsR
t)) [PrimExpr
condExpr]
  where Column PrimExpr
condExpr = columnsR -> Field SqlBool
cond columnsR
tableCols
        TI.View columnsR
tableCols = forall writeColumns viewColumns.
TableFields writeColumns viewColumns -> View viewColumns
TI.tableColumnsView (forall writeColumns viewColumns.
Table writeColumns viewColumns
-> TableFields writeColumns viewColumns
TI.tableColumns Table a columnsR
t)

arrangeUpdate :: T.Table columnsW columnsR
              -> (columnsR -> columnsW) -> (columnsR -> Field SqlBool)
              -> HSql.SqlUpdate
arrangeUpdate :: forall columnsW columnsR.
Table columnsW columnsR
-> (columnsR -> columnsW)
-> (columnsR -> Field SqlBool)
-> SqlUpdate
arrangeUpdate Table columnsW columnsR
t columnsR -> columnsW
update columnsR -> Field SqlBool
cond =
  SqlGenerator -> SqlTable -> [PrimExpr] -> Assoc -> SqlUpdate
SG.sqlUpdate SqlGenerator
SD.defaultSqlGenerator
               (TableIdentifier -> SqlTable
PQ.tiToSqlTable (forall writeColumns viewColumns.
Table writeColumns viewColumns -> TableIdentifier
TI.tableIdentifier Table columnsW columnsR
t))
               [PrimExpr
condExpr] (columnsR -> Assoc
update' columnsR
tableCols)
  where TI.TableFields Writer columnsW columnsR
writer (TI.View columnsR
tableCols) = forall writeColumns viewColumns.
Table writeColumns viewColumns
-> TableFields writeColumns viewColumns
TI.tableColumns Table columnsW columnsR
t
        update' :: columnsR -> Assoc
update' = forall a b. (a -> b) -> [a] -> [b]
map (\(PrimExpr
x, String
y) -> (String
y, PrimExpr
x)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall columns columns'.
Writer columns columns' -> columns -> [(PrimExpr, String)]
TI.runWriter Writer columnsW columnsR
writer forall b c a. (b -> c) -> (a -> b) -> a -> c
. columnsR -> columnsW
update
        Column PrimExpr
condExpr = columnsR -> Field SqlBool
cond columnsR
tableCols

arrangeUpdateSql :: T.Table columnsW columnsR
              -> (columnsR -> columnsW) -> (columnsR -> Field SqlBool)
              -> String
arrangeUpdateSql :: forall columnsW columnsR.
Table columnsW columnsR
-> (columnsR -> columnsW) -> (columnsR -> Field SqlBool) -> String
arrangeUpdateSql = forall a. Show a => a -> String
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqlUpdate -> Doc
HPrint.ppUpdate forall r z a b c.
(r -> z) -> (a -> b -> c -> r) -> a -> b -> c -> z
.:. forall columnsW columnsR.
Table columnsW columnsR
-> (columnsR -> columnsW)
-> (columnsR -> Field SqlBool)
-> SqlUpdate
arrangeUpdate

arrangeDeleteSql :: T.Table a columnsR -> (columnsR -> Field SqlBool) -> String
arrangeDeleteSql :: forall a columnsR.
Table a columnsR -> (columnsR -> Field SqlBool) -> String
arrangeDeleteSql = forall a. Show a => a -> String
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. SqlDelete -> Doc
HPrint.ppDelete forall r z a b. (r -> z) -> (a -> b -> r) -> a -> b -> z
.: forall a columnsR.
Table a columnsR -> (columnsR -> Field SqlBool) -> SqlDelete
arrangeDelete

arrangeUpdateReturning :: U.Unpackspec columnsReturned ignored
                       -> T.Table columnsW columnsR
                       -> (columnsR -> columnsW)
                       -> (columnsR -> Field SqlBool)
                       -> (columnsR -> columnsReturned)
                       -> Sql.Returning HSql.SqlUpdate
arrangeUpdateReturning :: forall columnsReturned ignored columnsW columnsR.
Unpackspec columnsReturned ignored
-> Table columnsW columnsR
-> (columnsR -> columnsW)
-> (columnsR -> Field SqlBool)
-> (columnsR -> columnsReturned)
-> Returning SqlUpdate
arrangeUpdateReturning Unpackspec columnsReturned ignored
unpackspec Table columnsW columnsR
t columnsR -> columnsW
updatef columnsR -> Field SqlBool
cond columnsR -> columnsReturned
returningf =
  forall a. a -> NonEmpty SqlExpr -> Returning a
Sql.Returning SqlUpdate
update NonEmpty SqlExpr
returningSEs
  where update :: SqlUpdate
update = forall columnsW columnsR.
Table columnsW columnsR
-> (columnsR -> columnsW)
-> (columnsR -> Field SqlBool)
-> SqlUpdate
arrangeUpdate Table columnsW columnsR
t columnsR -> columnsW
updatef columnsR -> Field SqlBool
cond
        TI.View columnsR
columnsR = forall writeColumns viewColumns.
TableFields writeColumns viewColumns -> View viewColumns
TI.tableColumnsView (forall writeColumns viewColumns.
Table writeColumns viewColumns
-> TableFields writeColumns viewColumns
TI.tableColumns Table columnsW columnsR
t)
        returningPEs :: [PrimExpr]
returningPEs = forall s t. Unpackspec s t -> s -> [PrimExpr]
U.collectPEs Unpackspec columnsReturned ignored
unpackspec (columnsR -> columnsReturned
returningf columnsR
columnsR)
        returningSEs :: NonEmpty SqlExpr
returningSEs = forall a. (SqlExpr -> a) -> [a] -> NonEmpty a
Sql.ensureColumnsGen forall a. a -> a
id (forall a b. (a -> b) -> [a] -> [b]
map PrimExpr -> SqlExpr
Sql.sqlExpr [PrimExpr]
returningPEs)

arrangeUpdateReturningSql :: U.Unpackspec columnsReturned ignored
                          -> T.Table columnsW columnsR
                          -> (columnsR -> columnsW)
                          -> (columnsR -> Field SqlBool)
                          -> (columnsR -> columnsReturned)
                          -> String
arrangeUpdateReturningSql :: forall columnsReturned ignored columnsW columnsR.
Unpackspec columnsReturned ignored
-> Table columnsW columnsR
-> (columnsR -> columnsW)
-> (columnsR -> Field SqlBool)
-> (columnsR -> columnsReturned)
-> String
arrangeUpdateReturningSql =
  forall a. Show a => a -> String
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. Returning SqlUpdate -> Doc
Print.ppUpdateReturning forall r z a b c d e.
(r -> z)
-> (a -> b -> c -> d -> e -> r) -> a -> b -> c -> d -> e -> z
.::. forall columnsReturned ignored columnsW columnsR.
Unpackspec columnsReturned ignored
-> Table columnsW columnsR
-> (columnsR -> columnsW)
-> (columnsR -> Field SqlBool)
-> (columnsR -> columnsReturned)
-> Returning SqlUpdate
arrangeUpdateReturning