{-# LANGUAGE PatternSynonyms #-}

module Database.DuckDB.Value
    ( -- * Query result
      DuckDBResult
    , DuckDBDataChunk
    , DuckDBVector
    , DuckDBType
    , DuckDBLogicalType
    , destroy

      -- * Data types
    , pattern FFI.DUCKDB_TYPE_INVALID
    , pattern FFI.DUCKDB_TYPE_BOOLEAN
    , pattern FFI.DUCKDB_TYPE_TINYINT
    , pattern FFI.DUCKDB_TYPE_SMALLINT
    , pattern FFI.DUCKDB_TYPE_INTEGER
    , pattern FFI.DUCKDB_TYPE_BIGINT
    , pattern FFI.DUCKDB_TYPE_UTINYINT
    , pattern FFI.DUCKDB_TYPE_USMALLINT
    , pattern FFI.DUCKDB_TYPE_UINTEGER
    , pattern FFI.DUCKDB_TYPE_UBIGINT
    , pattern FFI.DUCKDB_TYPE_FLOAT
    , pattern FFI.DUCKDB_TYPE_DOUBLE
    , pattern FFI.DUCKDB_TYPE_TIMESTAMP
    , pattern FFI.DUCKDB_TYPE_DATE
    , pattern FFI.DUCKDB_TYPE_TIME
    , pattern FFI.DUCKDB_TYPE_INTERVAL
    , pattern FFI.DUCKDB_TYPE_HUGEINT
    , pattern FFI.DUCKDB_TYPE_VARCHAR
    , pattern FFI.DUCKDB_TYPE_BLOB
    , pattern FFI.DUCKDB_TYPE_DECIMAL
    , pattern FFI.DUCKDB_TYPE_TIMESTAMP_S
    , pattern FFI.DUCKDB_TYPE_TIMESTAMP_MS
    , pattern FFI.DUCKDB_TYPE_TIMESTAMP_NS
    , pattern FFI.DUCKDB_TYPE_ENUM
    , pattern FFI.DUCKDB_TYPE_LIST
    , pattern FFI.DUCKDB_TYPE_STRUCT
    , pattern FFI.DUCKDB_TYPE_MAP
    , pattern FFI.DUCKDB_TYPE_UUID
    , pattern FFI.DUCKDB_TYPE_UNION
    , pattern FFI.DUCKDB_TYPE_BIT
    , typeRep
    , Int8
    , Int16
    , Int32
    , Int64
    , Word8
    , Word16
    , Word32
    , Word64
    , DuckDBDate
    , DuckDBTime
    , DuckDBTimestamp

      -- * Columns
    , columnName
    , columnType
    , columnLogicalType
    , columnCount
    , rowCount
    , rowsChanged
    , columnData
    , nullmaskData

      -- * Data chunks
    , chunkAt
    , isStreaming
    , chunkCount
    , createChunk
    , destroyChunk
    , resetChunk
    , getChunkColumnCount
    , getChunkVector
    , getChunkSize
    , setChunkSize
    , getVectorType
    , getVectorData
    , getVectorValidity
    , ensureVectorValidityWritable
    , setVectorStringValue
    , isValidityRowValid
    , setValidityRow
    , setValidityRowInvalid
    , setValidityRowValid

      -- * Element values
    , valueBoolean
    , valueInt8
    , valueInt16
    , valueInt32
    , valueInt64
    , valueUint8
    , valueUint16
    , valueUint32
    , valueUint64
    , valueFloat
    , valueDouble
    , valueDate
    , valueTime
    , valueTimestamp
    , valueVarChar
    , valueVarCharInternal
    , valueIsNull
    )
where

import Control.Monad
import Control.Monad.Except
import Control.Monad.IO.Class
import Data.Coerce
import Data.Int
import Data.Typeable (TypeRep, typeOf)
import Data.Word
import Database.DuckDB.Internal
import Database.DuckDB.Internal.FFI
    ( DuckDBDataChunk
    , DuckDBDate
    , DuckDBLogicalType
    , DuckDBTime
    , DuckDBTimestamp
    , DuckDBType
    , DuckDBVector
    )
import Database.DuckDB.Internal.FFI qualified as FFI
import Foreign.C.String
import Foreign.Marshal.Alloc
import Foreign.Marshal.Array
import Foreign.Ptr
import Foreign.Storable

type DuckDBResult = Ptr FFI.DuckDBResult

destroy :: DuckDBResult -> DuckDBMonad ()
destroy :: DuckDBResult -> DuckDBMonad ()
destroy DuckDBResult
result = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    DuckDBResult -> IO ()
FFI.duckdb_destroy_result DuckDBResult
result
    forall a. Ptr a -> IO ()
FFI.duckdb_free DuckDBResult
result

typeRep :: DuckDBType -> TypeRep
typeRep :: DuckDBType -> TypeRep
typeRep DuckDBType
FFI.DUCKDB_TYPE_INVALID = forall a. Typeable a => a -> TypeRep
typeOf ()
typeRep DuckDBType
FFI.DUCKDB_TYPE_BOOLEAN = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Bool)
typeRep DuckDBType
FFI.DUCKDB_TYPE_TINYINT = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int8)
typeRep DuckDBType
FFI.DUCKDB_TYPE_SMALLINT = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int16)
typeRep DuckDBType
FFI.DUCKDB_TYPE_INTEGER = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int32)
typeRep DuckDBType
FFI.DUCKDB_TYPE_BIGINT = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int64)
typeRep DuckDBType
FFI.DUCKDB_TYPE_UTINYINT = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Word8)
typeRep DuckDBType
FFI.DUCKDB_TYPE_USMALLINT = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Word16)
typeRep DuckDBType
FFI.DUCKDB_TYPE_UINTEGER = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Word32)
typeRep DuckDBType
FFI.DUCKDB_TYPE_UBIGINT = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Word64)
typeRep DuckDBType
FFI.DUCKDB_TYPE_FLOAT = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Float)
typeRep DuckDBType
FFI.DUCKDB_TYPE_DOUBLE = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Double)
typeRep DuckDBType
FFI.DUCKDB_TYPE_TIMESTAMP = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int64)
typeRep DuckDBType
FFI.DUCKDB_TYPE_DATE = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int32)
typeRep DuckDBType
FFI.DUCKDB_TYPE_TIME = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int64)
typeRep DuckDBType
FFI.DUCKDB_TYPE_INTERVAL = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int64)
typeRep DuckDBType
FFI.DUCKDB_TYPE_HUGEINT = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int64)
typeRep DuckDBType
FFI.DUCKDB_TYPE_VARCHAR = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: String)
typeRep DuckDBType
FFI.DUCKDB_TYPE_BLOB = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: String)
typeRep DuckDBType
FFI.DUCKDB_TYPE_DECIMAL = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Double)
typeRep DuckDBType
FFI.DUCKDB_TYPE_TIMESTAMP_S = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int64)
typeRep DuckDBType
FFI.DUCKDB_TYPE_TIMESTAMP_MS = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int64)
typeRep DuckDBType
FFI.DUCKDB_TYPE_TIMESTAMP_NS = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int64)
typeRep DuckDBType
FFI.DUCKDB_TYPE_ENUM = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int32)
typeRep DuckDBType
FFI.DUCKDB_TYPE_LIST = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int64)
typeRep DuckDBType
FFI.DUCKDB_TYPE_STRUCT = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int64)
typeRep DuckDBType
FFI.DUCKDB_TYPE_MAP = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int64)
typeRep DuckDBType
FFI.DUCKDB_TYPE_UUID = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int64)
typeRep DuckDBType
FFI.DUCKDB_TYPE_UNION = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int64)
typeRep DuckDBType
FFI.DUCKDB_TYPE_BIT = forall a. Typeable a => a -> TypeRep
typeOf (forall a. HasCallStack => a
undefined :: Int64)
typeRep DuckDBType
ty = forall a. HasCallStack => String -> a
error (String
"impossible: unknown duckdb type enumeration: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show DuckDBType
ty)

columnName :: DuckDBResult -> Int -> DuckDBMonad String
columnName :: DuckDBResult -> Int -> DuckDBMonad String
columnName DuckDBResult
result Int
idx = do
    CString
name' <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> IO CString
FFI.duckdb_column_name DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
idx)
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (CString
name' forall a. Eq a => a -> a -> Bool
== forall a. Ptr a
nullPtr) forall a b. (a -> b) -> a -> b
$
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError String
"duckdb_column_name failed"
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ CString -> IO String
peekCString CString
name'

columnType :: DuckDBResult -> Int -> DuckDBMonad DuckDBType
columnType :: DuckDBResult -> Int -> DuckDBMonad DuckDBType
columnType DuckDBResult
result Int
idx = do
    DuckDBType
ty <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> IO DuckDBType
FFI.duckdb_column_type DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
idx)
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DuckDBType
ty forall a. Eq a => a -> a -> Bool
== DuckDBType
FFI.DUCKDB_TYPE_INVALID) forall a b. (a -> b) -> a -> b
$
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError String
"duckdb_column_type failed"
    forall (m :: * -> *) a. Monad m => a -> m a
return DuckDBType
ty

columnLogicalType :: DuckDBResult -> Int -> DuckDBMonad DuckDBLogicalType
columnLogicalType :: DuckDBResult -> Int -> DuckDBMonad DuckDBLogicalType
columnLogicalType DuckDBResult
result Int
idx = do
    DuckDBLogicalType
ty <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> IO DuckDBLogicalType
FFI.duckdb_column_logical_type DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
idx)
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (coerce :: forall a b. Coercible a b => a -> b
coerce DuckDBLogicalType
ty forall a. Eq a => a -> a -> Bool
== forall a. Ptr a
nullPtr) forall a b. (a -> b) -> a -> b
$
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError String
"duckdb_column_logical_type failed"
    forall (m :: * -> *) a. Monad m => a -> m a
return DuckDBLogicalType
ty

columnCount :: DuckDBResult -> DuckDBMonad Int
columnCount :: DuckDBResult -> DuckDBMonad Int
columnCount DuckDBResult
result = do
    DuckDBIndexType
count <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> IO DuckDBIndexType
FFI.duckdb_column_count DuckDBResult
result
    forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. (Integral a, Num b) => a -> b
fromIntegral DuckDBIndexType
count)

rowCount :: DuckDBResult -> DuckDBMonad Int
rowCount :: DuckDBResult -> DuckDBMonad Int
rowCount DuckDBResult
result = do
    DuckDBIndexType
count <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> IO DuckDBIndexType
FFI.duckdb_row_count DuckDBResult
result
    forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. (Integral a, Num b) => a -> b
fromIntegral DuckDBIndexType
count)

rowsChanged :: DuckDBResult -> DuckDBMonad Int
rowsChanged :: DuckDBResult -> DuckDBMonad Int
rowsChanged DuckDBResult
result = do
    DuckDBIndexType
count <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> IO DuckDBIndexType
FFI.duckdb_rows_changed DuckDBResult
result
    forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. (Integral a, Num b) => a -> b
fromIntegral DuckDBIndexType
count)

columnData :: DuckDBResult -> Int -> DuckDBMonad (Ptr a)
columnData :: forall a. DuckDBResult -> Int -> DuckDBMonad (Ptr a)
columnData DuckDBResult
result Int
idx = do
    Ptr a
data' <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. DuckDBResult -> DuckDBIndexType -> IO (Ptr a)
FFI.duckdb_column_data DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
idx)
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Ptr a
data' forall a. Eq a => a -> a -> Bool
== forall a. Ptr a
nullPtr) forall a b. (a -> b) -> a -> b
$
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError String
"duckdb_column_data failed"
    forall (m :: * -> *) a. Monad m => a -> m a
return Ptr a
data'

nullmaskData :: DuckDBResult -> Int -> DuckDBMonad (Ptr Bool)
nullmaskData :: DuckDBResult -> Int -> DuckDBMonad (Ptr Bool)
nullmaskData DuckDBResult
result Int
idx = do
    Ptr Bool
data' <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> IO (Ptr Bool)
FFI.duckdb_nullmask_data DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
idx)
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Ptr Bool
data' forall a. Eq a => a -> a -> Bool
== forall a. Ptr a
nullPtr) forall a b. (a -> b) -> a -> b
$
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError String
"duckdb_nullmask_data failed"
    forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Bool
data'

chunkAt :: DuckDBResult -> Int -> DuckDBMonad DuckDBDataChunk
chunkAt :: DuckDBResult -> Int -> DuckDBMonad DuckDBDataChunk
chunkAt DuckDBResult
result Int
idx = do
    DuckDBDataChunk
chk <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
        DuckDBResult -> DuckDBIndexType -> IO DuckDBDataChunk
FFI.duckdb_result_get_chunk DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
idx)
    forall (m :: * -> *) a. Monad m => a -> m a
return DuckDBDataChunk
chk

isStreaming :: DuckDBResult -> DuckDBMonad Bool
isStreaming :: DuckDBResult -> DuckDBMonad Bool
isStreaming DuckDBResult
result = do
    Bool
streaming <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
        DuckDBResult -> IO Bool
FFI.duckdb_result_is_streaming DuckDBResult
result
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
streaming

chunkCount :: DuckDBResult -> DuckDBMonad Int
chunkCount :: DuckDBResult -> DuckDBMonad Int
chunkCount DuckDBResult
result = do
    DuckDBIndexType
count <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
        DuckDBResult -> IO DuckDBIndexType
FFI.duckdb_result_chunk_count DuckDBResult
result
    forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. (Integral a, Num b) => a -> b
fromIntegral DuckDBIndexType
count)

createChunk
    :: [DuckDBLogicalType]
    -> Int
    -- ^ column count
    -> DuckDBMonad DuckDBDataChunk
createChunk :: [DuckDBLogicalType] -> Int -> DuckDBMonad DuckDBDataChunk
createChunk [DuckDBLogicalType]
tys Int
colCount = do
    DuckDBDataChunk
chk <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray [DuckDBLogicalType]
tys forall a b. (a -> b) -> a -> b
$ \Ptr DuckDBLogicalType
tys' -> Ptr DuckDBLogicalType -> DuckDBIndexType -> IO DuckDBDataChunk
FFI.duckdb_create_data_chunk Ptr DuckDBLogicalType
tys' (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
colCount)
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (coerce :: forall a b. Coercible a b => a -> b
coerce DuckDBDataChunk
chk forall a. Eq a => a -> a -> Bool
== forall a. Ptr a
nullPtr) forall a b. (a -> b) -> a -> b
$
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError String
"duckdb_create_data_chunk failed"
    forall (m :: * -> *) a. Monad m => a -> m a
return DuckDBDataChunk
chk

destroyChunk :: DuckDBDataChunk -> DuckDBMonad ()
destroyChunk :: DuckDBDataChunk -> DuckDBMonad ()
destroyChunk DuckDBDataChunk
chk = 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 DuckDBDataChunk
chk' -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr DuckDBDataChunk
chk' DuckDBDataChunk
chk
    Ptr DuckDBDataChunk -> IO ()
FFI.duckdb_destroy_data_chunk Ptr DuckDBDataChunk
chk'

resetChunk :: DuckDBDataChunk -> DuckDBMonad ()
resetChunk :: DuckDBDataChunk -> DuckDBMonad ()
resetChunk DuckDBDataChunk
chk = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBDataChunk -> IO ()
FFI.duckdb_data_chunk_reset DuckDBDataChunk
chk

getChunkColumnCount :: DuckDBDataChunk -> DuckDBMonad Int
getChunkColumnCount :: DuckDBDataChunk -> DuckDBMonad Int
getChunkColumnCount DuckDBDataChunk
chk = do
    DuckDBIndexType
count <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBDataChunk -> IO DuckDBIndexType
FFI.duckdb_data_chunk_get_column_count DuckDBDataChunk
chk
    forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. (Integral a, Num b) => a -> b
fromIntegral DuckDBIndexType
count)

getChunkVector :: DuckDBDataChunk -> Int -> DuckDBMonad DuckDBVector
getChunkVector :: DuckDBDataChunk -> Int -> DuckDBMonad DuckDBVector
getChunkVector DuckDBDataChunk
chk Int
idx = do
    DuckDBVector
vec <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBDataChunk -> DuckDBIndexType -> IO DuckDBVector
FFI.duckdb_data_chunk_get_vector DuckDBDataChunk
chk (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
idx)
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (coerce :: forall a b. Coercible a b => a -> b
coerce DuckDBVector
vec forall a. Eq a => a -> a -> Bool
== forall a. Ptr a
nullPtr) forall a b. (a -> b) -> a -> b
$
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError String
"duckdb_data_chunk_get_vector failed"
    forall (m :: * -> *) a. Monad m => a -> m a
return DuckDBVector
vec

getChunkSize :: DuckDBDataChunk -> DuckDBMonad Int
getChunkSize :: DuckDBDataChunk -> DuckDBMonad Int
getChunkSize DuckDBDataChunk
chk = do
    DuckDBIndexType
size <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBDataChunk -> IO DuckDBIndexType
FFI.duckdb_data_chunk_get_size DuckDBDataChunk
chk
    forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. (Integral a, Num b) => a -> b
fromIntegral DuckDBIndexType
size)

setChunkSize :: DuckDBDataChunk -> Int -> DuckDBMonad ()
setChunkSize :: DuckDBDataChunk -> Int -> DuckDBMonad ()
setChunkSize DuckDBDataChunk
chk Int
size = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBDataChunk -> DuckDBIndexType -> IO ()
FFI.duckdb_data_chunk_set_size DuckDBDataChunk
chk (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
size)

getVectorType :: DuckDBVector -> DuckDBMonad DuckDBLogicalType
getVectorType :: DuckDBVector -> DuckDBMonad DuckDBLogicalType
getVectorType DuckDBVector
vec = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBVector -> IO DuckDBLogicalType
FFI.duckdb_vector_get_column_type DuckDBVector
vec

getVectorData :: DuckDBVector -> DuckDBMonad (Ptr a)
getVectorData :: forall a. DuckDBVector -> DuckDBMonad (Ptr a)
getVectorData DuckDBVector
vec = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. DuckDBVector -> IO (Ptr a)
FFI.duckdb_vector_get_data DuckDBVector
vec

getVectorValidity :: DuckDBVector -> DuckDBMonad (Ptr Word64)
getVectorValidity :: DuckDBVector -> DuckDBMonad (Ptr DuckDBIndexType)
getVectorValidity DuckDBVector
vec = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBVector -> IO (Ptr DuckDBIndexType)
FFI.duckdb_vector_get_validity DuckDBVector
vec

ensureVectorValidityWritable :: DuckDBVector -> DuckDBMonad ()
ensureVectorValidityWritable :: DuckDBVector -> DuckDBMonad ()
ensureVectorValidityWritable DuckDBVector
vec = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBVector -> IO ()
FFI.duckdb_vector_ensure_validity_writable DuckDBVector
vec

setVectorStringValue :: DuckDBVector -> Int -> String -> DuckDBMonad ()
setVectorStringValue :: DuckDBVector -> Int -> String -> DuckDBMonad ()
setVectorStringValue DuckDBVector
vec Int
idx String
value = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. String -> (CString -> IO a) -> IO a
withCString String
value forall a b. (a -> b) -> a -> b
$ \CString
value' ->
    DuckDBVector -> DuckDBIndexType -> CString -> IO ()
FFI.duckdb_vector_assign_string_element DuckDBVector
vec (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
idx) CString
value'

isValidityRowValid :: Ptr Word64 -> Int -> DuckDBMonad Bool
isValidityRowValid :: Ptr DuckDBIndexType -> Int -> DuckDBMonad Bool
isValidityRowValid Ptr DuckDBIndexType
vec Int
idx = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ Ptr DuckDBIndexType -> DuckDBIndexType -> IO Bool
FFI.duckdb_validity_row_is_valid Ptr DuckDBIndexType
vec (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
idx)

setValidityRow :: Ptr Word64 -> Int -> Bool -> DuckDBMonad ()
setValidityRow :: Ptr DuckDBIndexType -> Int -> Bool -> DuckDBMonad ()
setValidityRow Ptr DuckDBIndexType
vec Int
idx Bool
valid = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ Ptr DuckDBIndexType -> DuckDBIndexType -> Bool -> IO ()
FFI.duckdb_validity_set_row_validity Ptr DuckDBIndexType
vec (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
idx) Bool
valid

setValidityRowInvalid :: Ptr Word64 -> Int -> DuckDBMonad ()
setValidityRowInvalid :: Ptr DuckDBIndexType -> Int -> DuckDBMonad ()
setValidityRowInvalid Ptr DuckDBIndexType
vec Int
idx = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ Ptr DuckDBIndexType -> DuckDBIndexType -> IO ()
FFI.duckdb_validity_set_row_invalid Ptr DuckDBIndexType
vec (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
idx)

setValidityRowValid :: Ptr Word64 -> Int -> DuckDBMonad ()
setValidityRowValid :: Ptr DuckDBIndexType -> Int -> DuckDBMonad ()
setValidityRowValid Ptr DuckDBIndexType
vec Int
idx = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ Ptr DuckDBIndexType -> DuckDBIndexType -> IO ()
FFI.duckdb_validity_set_row_valid Ptr DuckDBIndexType
vec (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
idx)

valueBoolean
    :: DuckDBResult
    -> Int
    -- ^ column
    -> Int
    -- ^ row
    -> DuckDBMonad Bool
valueBoolean :: DuckDBResult -> Int -> Int -> DuckDBMonad Bool
valueBoolean DuckDBResult
result Int
col Int
row =
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Bool
FFI.duckdb_value_boolean DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
col) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
row)

valueInt8
    :: DuckDBResult
    -> Int
    -- ^ column
    -> Int
    -- ^ row
    -> DuckDBMonad Int8
valueInt8 :: DuckDBResult -> Int -> Int -> DuckDBMonad Int8
valueInt8 DuckDBResult
result Int
col Int
row = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Int8
FFI.duckdb_value_int8 DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
col) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
row)

valueInt16
    :: DuckDBResult
    -> Int
    -- ^ column
    -> Int
    -- ^ row
    -> DuckDBMonad Int16
valueInt16 :: DuckDBResult -> Int -> Int -> DuckDBMonad Int16
valueInt16 DuckDBResult
result Int
col Int
row = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Int16
FFI.duckdb_value_int16 DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
col) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
row)

valueInt32
    :: DuckDBResult
    -> Int
    -- ^ column
    -> Int
    -- ^ row
    -> DuckDBMonad Int32
valueInt32 :: DuckDBResult -> Int -> Int -> DuckDBMonad DuckDBType
valueInt32 DuckDBResult
result Int
col Int
row = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO DuckDBType
FFI.duckdb_value_int32 DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
col) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
row)

valueInt64
    :: DuckDBResult
    -> Int
    -- ^ column
    -> Int
    -- ^ row
    -> DuckDBMonad Int64
valueInt64 :: DuckDBResult -> Int -> Int -> DuckDBMonad Int64
valueInt64 DuckDBResult
result Int
col Int
row = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Int64
FFI.duckdb_value_int64 DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
col) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
row)

valueUint8
    :: DuckDBResult
    -> Int
    -- ^ column
    -> Int
    -- ^ row
    -> DuckDBMonad Word8
valueUint8 :: DuckDBResult -> Int -> Int -> DuckDBMonad Word8
valueUint8 DuckDBResult
result Int
col Int
row = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Word8
FFI.duckdb_value_uint8 DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
col) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
row)

valueUint16
    :: DuckDBResult
    -> Int
    -- ^ column
    -> Int
    -- ^ row
    -> DuckDBMonad Word16
valueUint16 :: DuckDBResult -> Int -> Int -> DuckDBMonad Word16
valueUint16 DuckDBResult
result Int
col Int
row = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Word16
FFI.duckdb_value_uint16 DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
col) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
row)

valueUint32
    :: DuckDBResult
    -> Int
    -- ^ column
    -> Int
    -- ^ row
    -> DuckDBMonad Word32
valueUint32 :: DuckDBResult -> Int -> Int -> DuckDBMonad Word32
valueUint32 DuckDBResult
result Int
col Int
row = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Word32
FFI.duckdb_value_uint32 DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
col) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
row)

valueUint64
    :: DuckDBResult
    -> Int
    -- ^ column
    -> Int
    -- ^ row
    -> DuckDBMonad Word64
valueUint64 :: DuckDBResult -> Int -> Int -> DuckDBMonad DuckDBIndexType
valueUint64 DuckDBResult
result Int
col Int
row = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult
-> DuckDBIndexType -> DuckDBIndexType -> IO DuckDBIndexType
FFI.duckdb_value_uint64 DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
col) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
row)

valueFloat
    :: DuckDBResult
    -> Int
    -- ^ column
    -> Int
    -- ^ row
    -> DuckDBMonad Float
valueFloat :: DuckDBResult -> Int -> Int -> DuckDBMonad Float
valueFloat DuckDBResult
result Int
col Int
row = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Float
FFI.duckdb_value_float DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
col) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
row)

valueDouble
    :: DuckDBResult
    -> Int
    -- ^ column
    -> Int
    -- ^ row
    -> DuckDBMonad Double
valueDouble :: DuckDBResult -> Int -> Int -> DuckDBMonad Double
valueDouble DuckDBResult
result Int
col Int
row = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Double
FFI.duckdb_value_double DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
col) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
row)

valueDate
    :: DuckDBResult
    -> Int
    -- ^ column
    -> Int
    -- ^ row
    -> DuckDBMonad DuckDBDate
valueDate :: DuckDBResult -> Int -> Int -> DuckDBMonad DuckDBType
valueDate DuckDBResult
result Int
col Int
row = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO DuckDBType
FFI.duckdb_value_date DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
col) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
row)

valueTime
    :: DuckDBResult
    -> Int
    -- ^ column
    -> Int
    -- ^ row
    -> DuckDBMonad DuckDBTime
valueTime :: DuckDBResult -> Int -> Int -> DuckDBMonad Int64
valueTime DuckDBResult
result Int
col Int
row = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Int64
FFI.duckdb_value_time DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
col) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
row)

valueTimestamp
    :: DuckDBResult
    -> Int
    -- ^ column
    -> Int
    -- ^ row
    -> DuckDBMonad DuckDBTimestamp
valueTimestamp :: DuckDBResult -> Int -> Int -> DuckDBMonad Int64
valueTimestamp DuckDBResult
result Int
col Int
row =
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Int64
FFI.duckdb_value_timestamp DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
col) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
row)

valueVarChar
    :: DuckDBResult
    -> Int
    -- ^ column
    -> Int
    -- ^ row
    -> DuckDBMonad String
valueVarChar :: DuckDBResult -> Int -> Int -> DuckDBMonad String
valueVarChar DuckDBResult
result Int
col Int
row = do
    CString
value <-
        forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO CString
FFI.duckdb_value_varchar DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
col) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
row)
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (CString
value forall a. Eq a => a -> a -> Bool
== forall a. Ptr a
nullPtr) forall a b. (a -> b) -> a -> b
$
        forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError String
"duckdb_value_varchar failed"
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ CString -> IO String
peekCString CString
value

valueVarCharInternal
    :: DuckDBResult
    -> Int
    -- ^ column
    -> Int
    -- ^ row
    -> DuckDBMonad CString
valueVarCharInternal :: DuckDBResult -> Int -> Int -> DuckDBMonad CString
valueVarCharInternal DuckDBResult
result Int
col Int
row =
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$
        DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO CString
FFI.duckdb_value_varchar_internal DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
col) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
row)

valueIsNull
    :: DuckDBResult
    -> Int
    -- ^ column
    -> Int
    -- ^ row
    -> DuckDBMonad Bool
valueIsNull :: DuckDBResult -> Int -> Int -> DuckDBMonad Bool
valueIsNull DuckDBResult
result Int
col Int
row =
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Bool
FFI.duckdb_value_is_null DuckDBResult
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
col) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
row)