module Database.DuckDB.Appender
    ( module Database.DuckDB.Value

      -- * Appender
    , appender
    , flushAppender
    , closeAppender
    , destroyAppender
    , withAppender

      -- * Appending
    , appenderBeginRow
    , appenderEndRow
    , withAppenderRow
    , appendBool
    , appendBoolUnsafe
    , appendInt8
    , appendInt8Unsafe
    , appendInt16
    , appendInt16Unsafe
    , appendInt32
    , appendInt32Unsafe
    , appendInt64
    , appendInt64Unsafe
    , appendWord8
    , appendWord8Unsafe
    , appendWord16
    , appendWord16Unsafe
    , appendWord32
    , appendWord32Unsafe
    , appendWord64
    , appendWord64Unsafe
    , appendFloat
    , appendFloatUnsafe
    , appendDouble
    , appendDoubleUnsafe
    , appendDate
    , appendDateUnsafe
    , appendTime
    , appendTimeUnsafe
    , appendTimestamp
    , appendTimestampUnsafe
    , appendString
    , appendStringUnsafe
    , appendNull
    , appendNullUnsafe
    , appendDataChunk
    )
where

import Control.Monad
import Control.Monad.Except
import Control.Monad.IO.Class
import Data.Int
import Data.Word
import Database.DuckDB.Internal
    ( DuckDBMonad
    , isDuckDBError
    , liftIOEither
    , runDuckDB
    )
import Database.DuckDB.Internal.FFI
    ( DuckDBAppender
    , DuckDBConnection
    )
import Database.DuckDB.Internal.FFI qualified as FFI
import Database.DuckDB.Value
import Foreign.C.String
import Foreign.Marshal.Alloc
import Foreign.Ptr
import Foreign.Storable

appender
    :: DuckDBConnection
    -> String
    -- ^ schema, null (empty) for default schema
    -> String
    -- ^ table name
    -> DuckDBMonad DuckDBAppender
appender :: DuckDBConnection -> [Char] -> [Char] -> DuckDBMonad DuckDBAppender
appender DuckDBConnection
conn [Char]
schema [Char]
table = do
    DuckDBAppender
app <- forall a. IO (Either [Char] a) -> DuckDBMonad a
liftIOEither forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> (CString -> IO a) -> IO a
withCString [Char]
schema forall a b. (a -> b) -> a -> b
$ \CString
schema' -> forall a. [Char] -> (CString -> IO a) -> IO a
withCString [Char]
table forall a b. (a -> b) -> a -> b
$ \CString
table' -> do
        forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca forall a b. (a -> b) -> a -> b
$ \Ptr DuckDBAppender
appender' -> forall a. DuckDBMonad a -> IO (Either [Char] a)
runDuckDB forall a b. (a -> b) -> a -> b
$ do
            let schema'' :: CString
schema'' =
                    if forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Char]
schema
                        then forall a. Ptr a
nullPtr
                        else CString
schema'
            DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBConnection
-> CString -> CString -> Ptr DuckDBAppender -> IO DuckDBState
FFI.duckdb_appender_create DuckDBConnection
conn CString
schema'' CString
table' Ptr DuckDBAppender
appender'
            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
                [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
                    DuckDBAppender
app <- forall a. Storable a => Ptr a -> IO a
peek Ptr DuckDBAppender
appender'
                    CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
                    CString -> IO [Char]
peekCString CString
p
                DuckDBState
_ <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ Ptr DuckDBAppender -> IO DuckDBState
FFI.duckdb_appender_destroy Ptr DuckDBAppender
appender'
                forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_appender_create failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message
            forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Ptr a -> IO a
peek Ptr DuckDBAppender
appender'
    forall (m :: * -> *) a. Monad m => a -> m a
return DuckDBAppender
app

flushAppender :: DuckDBAppender -> DuckDBMonad ()
flushAppender :: DuckDBAppender -> DuckDBMonad ()
flushAppender DuckDBAppender
app = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> IO DuckDBState
FFI.duckdb_appender_flush DuckDBAppender
app
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_appender_flush failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

closeAppender :: DuckDBAppender -> DuckDBMonad ()
closeAppender :: DuckDBAppender -> DuckDBMonad ()
closeAppender DuckDBAppender
app = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> IO DuckDBState
FFI.duckdb_appender_close DuckDBAppender
app
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_appender_close failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

destroyAppender :: DuckDBAppender -> DuckDBMonad ()
destroyAppender :: DuckDBAppender -> DuckDBMonad ()
destroyAppender DuckDBAppender
app = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca forall a b. (a -> b) -> a -> b
$ \Ptr DuckDBAppender
appender' -> do
        forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr DuckDBAppender
appender' DuckDBAppender
app
        Ptr DuckDBAppender -> IO DuckDBState
FFI.duckdb_appender_destroy Ptr DuckDBAppender
appender'
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_appender_destroy failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

withAppender
    :: DuckDBConnection
    -> String
    -- ^ schema, null (empty) for default schema
    -> String
    -- ^ table name
    -> (DuckDBAppender -> DuckDBMonad a)
    -> DuckDBMonad a
withAppender :: forall a.
DuckDBConnection
-> [Char]
-> [Char]
-> (DuckDBAppender -> DuckDBMonad a)
-> DuckDBMonad a
withAppender DuckDBConnection
conn [Char]
schema [Char]
table DuckDBAppender -> DuckDBMonad a
f = do
    DuckDBAppender
app <- DuckDBConnection -> [Char] -> [Char] -> DuckDBMonad DuckDBAppender
appender DuckDBConnection
conn [Char]
schema [Char]
table
    a
r <- DuckDBAppender -> DuckDBMonad a
f DuckDBAppender
app
    DuckDBAppender -> DuckDBMonad ()
destroyAppender DuckDBAppender
app
    forall (m :: * -> *) a. Monad m => a -> m a
return a
r

appenderBeginRow :: DuckDBAppender -> DuckDBMonad ()
appenderBeginRow :: DuckDBAppender -> DuckDBMonad ()
appenderBeginRow DuckDBAppender
app = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> IO DuckDBState
FFI.duckdb_appender_begin_row DuckDBAppender
app
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_appender_begin_row failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

appenderEndRow :: DuckDBAppender -> DuckDBMonad ()
appenderEndRow :: DuckDBAppender -> DuckDBMonad ()
appenderEndRow DuckDBAppender
app = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> IO DuckDBState
FFI.duckdb_appender_end_row DuckDBAppender
app
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_appender_end_row failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

withAppenderRow :: DuckDBAppender -> DuckDBMonad a -> DuckDBMonad a
withAppenderRow :: forall a. DuckDBAppender -> DuckDBMonad a -> DuckDBMonad a
withAppenderRow DuckDBAppender
app DuckDBMonad a
f = do
    DuckDBAppender -> DuckDBMonad ()
appenderBeginRow DuckDBAppender
app
    a
r <- DuckDBMonad a
f
    DuckDBAppender -> DuckDBMonad ()
appenderEndRow DuckDBAppender
app
    forall (m :: * -> *) a. Monad m => a -> m a
return a
r

appendBool :: DuckDBAppender -> Bool -> DuckDBMonad ()
appendBool :: DuckDBAppender -> Bool -> DuckDBMonad ()
appendBool DuckDBAppender
app Bool
b = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Bool -> IO DuckDBState
FFI.duckdb_append_bool DuckDBAppender
app Bool
b
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_append_bool failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

appendBoolUnsafe :: DuckDBAppender -> Bool -> DuckDBMonad ()
appendBoolUnsafe :: DuckDBAppender -> Bool -> DuckDBMonad ()
appendBoolUnsafe DuckDBAppender
app Bool
b = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Bool -> IO DuckDBState
FFI.duckdb_append_bool DuckDBAppender
app Bool
b

appendInt8 :: DuckDBAppender -> Int8 -> DuckDBMonad ()
appendInt8 :: DuckDBAppender -> Int8 -> DuckDBMonad ()
appendInt8 DuckDBAppender
app Int8
i = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Int8 -> IO DuckDBState
FFI.duckdb_append_int8 DuckDBAppender
app Int8
i
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_append_int8 failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

appendInt8Unsafe :: DuckDBAppender -> Int8 -> DuckDBMonad ()
appendInt8Unsafe :: DuckDBAppender -> Int8 -> DuckDBMonad ()
appendInt8Unsafe DuckDBAppender
app Int8
i = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Int8 -> IO DuckDBState
FFI.duckdb_append_int8 DuckDBAppender
app Int8
i

appendInt16 :: DuckDBAppender -> Int16 -> DuckDBMonad ()
appendInt16 :: DuckDBAppender -> Int16 -> DuckDBMonad ()
appendInt16 DuckDBAppender
app Int16
i = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Int16 -> IO DuckDBState
FFI.duckdb_append_int16 DuckDBAppender
app Int16
i
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_append_int16 failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

appendInt16Unsafe :: DuckDBAppender -> Int16 -> DuckDBMonad ()
appendInt16Unsafe :: DuckDBAppender -> Int16 -> DuckDBMonad ()
appendInt16Unsafe DuckDBAppender
app Int16
i = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Int16 -> IO DuckDBState
FFI.duckdb_append_int16 DuckDBAppender
app Int16
i

appendInt32 :: DuckDBAppender -> Int32 -> DuckDBMonad ()
appendInt32 :: DuckDBAppender -> DuckDBState -> DuckDBMonad ()
appendInt32 DuckDBAppender
app DuckDBState
i = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> DuckDBState -> IO DuckDBState
FFI.duckdb_append_int32 DuckDBAppender
app DuckDBState
i
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_append_int32 failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

appendInt32Unsafe :: DuckDBAppender -> Int32 -> DuckDBMonad ()
appendInt32Unsafe :: DuckDBAppender -> DuckDBState -> DuckDBMonad ()
appendInt32Unsafe DuckDBAppender
app DuckDBState
i = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> DuckDBState -> IO DuckDBState
FFI.duckdb_append_int32 DuckDBAppender
app DuckDBState
i

appendInt64 :: DuckDBAppender -> Int64 -> DuckDBMonad ()
appendInt64 :: DuckDBAppender -> Int64 -> DuckDBMonad ()
appendInt64 DuckDBAppender
app Int64
i = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Int64 -> IO DuckDBState
FFI.duckdb_append_int64 DuckDBAppender
app Int64
i
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_append_int64 failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

appendInt64Unsafe :: DuckDBAppender -> Int64 -> DuckDBMonad ()
appendInt64Unsafe :: DuckDBAppender -> Int64 -> DuckDBMonad ()
appendInt64Unsafe DuckDBAppender
app Int64
i = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Int64 -> IO DuckDBState
FFI.duckdb_append_int64 DuckDBAppender
app Int64
i

appendWord8 :: DuckDBAppender -> Word8 -> DuckDBMonad ()
appendWord8 :: DuckDBAppender -> Word8 -> DuckDBMonad ()
appendWord8 DuckDBAppender
app Word8
i = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Word8 -> IO DuckDBState
FFI.duckdb_append_uint8 DuckDBAppender
app Word8
i
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_append_uint8 failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

appendWord8Unsafe :: DuckDBAppender -> Word8 -> DuckDBMonad ()
appendWord8Unsafe :: DuckDBAppender -> Word8 -> DuckDBMonad ()
appendWord8Unsafe DuckDBAppender
app Word8
i = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Word8 -> IO DuckDBState
FFI.duckdb_append_uint8 DuckDBAppender
app Word8
i

appendWord16 :: DuckDBAppender -> Word16 -> DuckDBMonad ()
appendWord16 :: DuckDBAppender -> Word16 -> DuckDBMonad ()
appendWord16 DuckDBAppender
app Word16
i = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Word16 -> IO DuckDBState
FFI.duckdb_append_uint16 DuckDBAppender
app Word16
i
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_append_uint16 failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

appendWord16Unsafe :: DuckDBAppender -> Word16 -> DuckDBMonad ()
appendWord16Unsafe :: DuckDBAppender -> Word16 -> DuckDBMonad ()
appendWord16Unsafe DuckDBAppender
app Word16
i = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Word16 -> IO DuckDBState
FFI.duckdb_append_uint16 DuckDBAppender
app Word16
i

appendWord32 :: DuckDBAppender -> Word32 -> DuckDBMonad ()
appendWord32 :: DuckDBAppender -> Word32 -> DuckDBMonad ()
appendWord32 DuckDBAppender
app Word32
i = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Word32 -> IO DuckDBState
FFI.duckdb_append_uint32 DuckDBAppender
app Word32
i
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_append_uint32 failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

appendWord32Unsafe :: DuckDBAppender -> Word32 -> DuckDBMonad ()
appendWord32Unsafe :: DuckDBAppender -> Word32 -> DuckDBMonad ()
appendWord32Unsafe DuckDBAppender
app Word32
i = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Word32 -> IO DuckDBState
FFI.duckdb_append_uint32 DuckDBAppender
app Word32
i

appendWord64 :: DuckDBAppender -> Word64 -> DuckDBMonad ()
appendWord64 :: DuckDBAppender -> Word64 -> DuckDBMonad ()
appendWord64 DuckDBAppender
app Word64
i = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Word64 -> IO DuckDBState
FFI.duckdb_append_uint64 DuckDBAppender
app Word64
i
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_append_uint64 failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

appendWord64Unsafe :: DuckDBAppender -> Word64 -> DuckDBMonad ()
appendWord64Unsafe :: DuckDBAppender -> Word64 -> DuckDBMonad ()
appendWord64Unsafe DuckDBAppender
app Word64
i = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Word64 -> IO DuckDBState
FFI.duckdb_append_uint64 DuckDBAppender
app Word64
i

appendFloat :: DuckDBAppender -> Float -> DuckDBMonad ()
appendFloat :: DuckDBAppender -> Float -> DuckDBMonad ()
appendFloat DuckDBAppender
app Float
f = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Float -> IO DuckDBState
FFI.duckdb_append_float DuckDBAppender
app Float
f
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_append_float failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

appendFloatUnsafe :: DuckDBAppender -> Float -> DuckDBMonad ()
appendFloatUnsafe :: DuckDBAppender -> Float -> DuckDBMonad ()
appendFloatUnsafe DuckDBAppender
app Float
f = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Float -> IO DuckDBState
FFI.duckdb_append_float DuckDBAppender
app Float
f

appendDouble :: DuckDBAppender -> Double -> DuckDBMonad ()
appendDouble :: DuckDBAppender -> Double -> DuckDBMonad ()
appendDouble DuckDBAppender
app Double
d = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Double -> IO DuckDBState
FFI.duckdb_append_double DuckDBAppender
app Double
d
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_append_double failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

appendDoubleUnsafe :: DuckDBAppender -> Double -> DuckDBMonad ()
appendDoubleUnsafe :: DuckDBAppender -> Double -> DuckDBMonad ()
appendDoubleUnsafe DuckDBAppender
app Double
d = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Double -> IO DuckDBState
FFI.duckdb_append_double DuckDBAppender
app Double
d

appendDate :: DuckDBAppender -> Int32 -> DuckDBMonad ()
appendDate :: DuckDBAppender -> DuckDBState -> DuckDBMonad ()
appendDate DuckDBAppender
app DuckDBState
d = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> DuckDBState -> IO DuckDBState
FFI.duckdb_append_date DuckDBAppender
app DuckDBState
d
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_append_date failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

appendDateUnsafe :: DuckDBAppender -> Int32 -> DuckDBMonad ()
appendDateUnsafe :: DuckDBAppender -> DuckDBState -> DuckDBMonad ()
appendDateUnsafe DuckDBAppender
app DuckDBState
d = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> DuckDBState -> IO DuckDBState
FFI.duckdb_append_date DuckDBAppender
app DuckDBState
d

appendTime :: DuckDBAppender -> Int64 -> DuckDBMonad ()
appendTime :: DuckDBAppender -> Int64 -> DuckDBMonad ()
appendTime DuckDBAppender
app Int64
t = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Int64 -> IO DuckDBState
FFI.duckdb_append_time DuckDBAppender
app Int64
t
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_append_time failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

appendTimeUnsafe :: DuckDBAppender -> Int64 -> DuckDBMonad ()
appendTimeUnsafe :: DuckDBAppender -> Int64 -> DuckDBMonad ()
appendTimeUnsafe DuckDBAppender
app Int64
t = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Int64 -> IO DuckDBState
FFI.duckdb_append_time DuckDBAppender
app Int64
t

appendTimestamp :: DuckDBAppender -> Int64 -> DuckDBMonad ()
appendTimestamp :: DuckDBAppender -> Int64 -> DuckDBMonad ()
appendTimestamp DuckDBAppender
app Int64
t = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Int64 -> IO DuckDBState
FFI.duckdb_append_timestamp DuckDBAppender
app Int64
t
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_append_timestamp failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

appendTimestampUnsafe :: DuckDBAppender -> Int64 -> DuckDBMonad ()
appendTimestampUnsafe :: DuckDBAppender -> Int64 -> DuckDBMonad ()
appendTimestampUnsafe DuckDBAppender
app Int64
t = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> Int64 -> IO DuckDBState
FFI.duckdb_append_timestamp DuckDBAppender
app Int64
t

appendString :: DuckDBAppender -> String -> DuckDBMonad ()
appendString :: DuckDBAppender -> [Char] -> DuckDBMonad ()
appendString DuckDBAppender
app [Char]
s = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> (CString -> IO a) -> IO a
withCString [Char]
s forall a b. (a -> b) -> a -> b
$ \CString
s' -> DuckDBAppender -> CString -> IO DuckDBState
FFI.duckdb_append_varchar DuckDBAppender
app CString
s'
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_append_varchar failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

appendStringUnsafe :: DuckDBAppender -> String -> DuckDBMonad ()
appendStringUnsafe :: DuckDBAppender -> [Char] -> DuckDBMonad ()
appendStringUnsafe DuckDBAppender
app [Char]
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> (CString -> IO a) -> IO a
withCString [Char]
s forall a b. (a -> b) -> a -> b
$ \CString
s' -> DuckDBAppender -> CString -> IO DuckDBState
FFI.duckdb_append_varchar DuckDBAppender
app CString
s'

appendNull :: DuckDBAppender -> DuckDBMonad ()
appendNull :: DuckDBAppender -> DuckDBMonad ()
appendNull DuckDBAppender
app = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> IO DuckDBState
FFI.duckdb_append_null DuckDBAppender
app
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_append_null failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message

appendNullUnsafe :: DuckDBAppender -> DuckDBMonad ()
appendNullUnsafe :: DuckDBAppender -> DuckDBMonad ()
appendNullUnsafe DuckDBAppender
app = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> IO DuckDBState
FFI.duckdb_append_null DuckDBAppender
app

appendDataChunk :: DuckDBAppender -> DuckDBDataChunk -> DuckDBMonad ()
appendDataChunk :: DuckDBAppender -> DuckDBDataChunk -> DuckDBMonad ()
appendDataChunk DuckDBAppender
app DuckDBDataChunk
chk = do
    DuckDBState
err <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBAppender -> DuckDBDataChunk -> IO DuckDBState
FFI.duckdb_append_data_chunk DuckDBAppender
app DuckDBDataChunk
chk
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBState -> Bool
isDuckDBError DuckDBState
err) forall a b. (a -> b) -> a -> b
$ do
        [Char]
message <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
            CString
p <- DuckDBAppender -> IO CString
FFI.duckdb_appender_error DuckDBAppender
app
            CString -> IO [Char]
peekCString CString
p
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ [Char]
"duckdb_append_chunk failed: " forall a. [a] -> [a] -> [a]
++ [Char]
message