{-# LINE 1 "src/Database/DuckDB/Internal/FFI.hsc" #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE PatternSynonyms #-}

module Database.DuckDB.Internal.FFI where

import Data.Int
import Data.Word
import Foreign.C.String
import Foreign.C.Types
import Foreign.Ptr
import Foreign.Storable

{- FOURMOLU_DISABLE -}




{- FOURMOLU_ENABLE -}

type DuckDBIndexType = Word64

type DuckDBType = Int32

pattern DUCKDB_TYPE_INVALID :: DuckDBType
pattern $bDUCKDB_TYPE_INVALID :: DuckDBPendingState
$mDUCKDB_TYPE_INVALID :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_INVALID = 0

pattern DUCKDB_TYPE_BOOLEAN :: DuckDBType
pattern $bDUCKDB_TYPE_BOOLEAN :: DuckDBPendingState
$mDUCKDB_TYPE_BOOLEAN :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_BOOLEAN = 1

pattern DUCKDB_TYPE_TINYINT :: DuckDBType
pattern $bDUCKDB_TYPE_TINYINT :: DuckDBPendingState
$mDUCKDB_TYPE_TINYINT :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_TINYINT = 2

pattern DUCKDB_TYPE_SMALLINT :: DuckDBType
pattern $bDUCKDB_TYPE_SMALLINT :: DuckDBPendingState
$mDUCKDB_TYPE_SMALLINT :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_SMALLINT = 3

pattern DUCKDB_TYPE_INTEGER :: DuckDBType
pattern $bDUCKDB_TYPE_INTEGER :: DuckDBPendingState
$mDUCKDB_TYPE_INTEGER :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_INTEGER = 4

pattern DUCKDB_TYPE_BIGINT :: DuckDBType
pattern $bDUCKDB_TYPE_BIGINT :: DuckDBPendingState
$mDUCKDB_TYPE_BIGINT :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_BIGINT = 5

pattern DUCKDB_TYPE_UTINYINT :: DuckDBType
pattern $bDUCKDB_TYPE_UTINYINT :: DuckDBPendingState
$mDUCKDB_TYPE_UTINYINT :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_UTINYINT = 6

pattern DUCKDB_TYPE_USMALLINT :: DuckDBType
pattern $bDUCKDB_TYPE_USMALLINT :: DuckDBPendingState
$mDUCKDB_TYPE_USMALLINT :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_USMALLINT = 7

pattern DUCKDB_TYPE_UINTEGER :: DuckDBType
pattern $bDUCKDB_TYPE_UINTEGER :: DuckDBPendingState
$mDUCKDB_TYPE_UINTEGER :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_UINTEGER = 8

pattern DUCKDB_TYPE_UBIGINT :: DuckDBType
pattern $bDUCKDB_TYPE_UBIGINT :: DuckDBPendingState
$mDUCKDB_TYPE_UBIGINT :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_UBIGINT = 9

pattern DUCKDB_TYPE_FLOAT :: DuckDBType
pattern $bDUCKDB_TYPE_FLOAT :: DuckDBPendingState
$mDUCKDB_TYPE_FLOAT :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_FLOAT = 10

pattern DUCKDB_TYPE_DOUBLE :: DuckDBType
pattern $bDUCKDB_TYPE_DOUBLE :: DuckDBPendingState
$mDUCKDB_TYPE_DOUBLE :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_DOUBLE = 11

pattern DUCKDB_TYPE_TIMESTAMP :: DuckDBType
pattern $bDUCKDB_TYPE_TIMESTAMP :: DuckDBPendingState
$mDUCKDB_TYPE_TIMESTAMP :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_TIMESTAMP = 12

pattern DUCKDB_TYPE_DATE :: DuckDBType
pattern $bDUCKDB_TYPE_DATE :: DuckDBPendingState
$mDUCKDB_TYPE_DATE :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_DATE = 13

pattern DUCKDB_TYPE_TIME :: DuckDBType
pattern $bDUCKDB_TYPE_TIME :: DuckDBPendingState
$mDUCKDB_TYPE_TIME :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_TIME = 14

pattern DUCKDB_TYPE_INTERVAL :: DuckDBType
pattern $bDUCKDB_TYPE_INTERVAL :: DuckDBPendingState
$mDUCKDB_TYPE_INTERVAL :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_INTERVAL = 15

pattern DUCKDB_TYPE_HUGEINT :: DuckDBType
pattern $bDUCKDB_TYPE_HUGEINT :: DuckDBPendingState
$mDUCKDB_TYPE_HUGEINT :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_HUGEINT = 16

pattern DUCKDB_TYPE_VARCHAR :: DuckDBType
pattern $bDUCKDB_TYPE_VARCHAR :: DuckDBPendingState
$mDUCKDB_TYPE_VARCHAR :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_VARCHAR = 17

pattern DUCKDB_TYPE_BLOB :: DuckDBType
pattern $bDUCKDB_TYPE_BLOB :: DuckDBPendingState
$mDUCKDB_TYPE_BLOB :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_BLOB = 18

pattern DUCKDB_TYPE_DECIMAL :: DuckDBType
pattern $bDUCKDB_TYPE_DECIMAL :: DuckDBPendingState
$mDUCKDB_TYPE_DECIMAL :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_DECIMAL = 19

pattern DUCKDB_TYPE_TIMESTAMP_S :: DuckDBType
pattern $bDUCKDB_TYPE_TIMESTAMP_S :: DuckDBPendingState
$mDUCKDB_TYPE_TIMESTAMP_S :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_TIMESTAMP_S = 20

pattern DUCKDB_TYPE_TIMESTAMP_MS :: DuckDBType
pattern $bDUCKDB_TYPE_TIMESTAMP_MS :: DuckDBPendingState
$mDUCKDB_TYPE_TIMESTAMP_MS :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_TIMESTAMP_MS = 21

pattern DUCKDB_TYPE_TIMESTAMP_NS :: DuckDBType
pattern $bDUCKDB_TYPE_TIMESTAMP_NS :: DuckDBPendingState
$mDUCKDB_TYPE_TIMESTAMP_NS :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_TIMESTAMP_NS = 22

pattern DUCKDB_TYPE_ENUM :: DuckDBType
pattern $bDUCKDB_TYPE_ENUM :: DuckDBPendingState
$mDUCKDB_TYPE_ENUM :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_ENUM = 23

pattern DUCKDB_TYPE_LIST :: DuckDBType
pattern $bDUCKDB_TYPE_LIST :: DuckDBPendingState
$mDUCKDB_TYPE_LIST :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_LIST = 24

pattern DUCKDB_TYPE_STRUCT :: DuckDBType
pattern $bDUCKDB_TYPE_STRUCT :: DuckDBPendingState
$mDUCKDB_TYPE_STRUCT :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_STRUCT = 25

pattern DUCKDB_TYPE_MAP :: DuckDBType
pattern $bDUCKDB_TYPE_MAP :: DuckDBPendingState
$mDUCKDB_TYPE_MAP :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_MAP = 26

pattern DUCKDB_TYPE_UUID :: DuckDBType
pattern $bDUCKDB_TYPE_UUID :: DuckDBPendingState
$mDUCKDB_TYPE_UUID :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_UUID = 27

pattern DUCKDB_TYPE_UNION :: DuckDBType
pattern $bDUCKDB_TYPE_UNION :: DuckDBPendingState
$mDUCKDB_TYPE_UNION :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_UNION = 28

pattern DUCKDB_TYPE_BIT :: DuckDBType
pattern $bDUCKDB_TYPE_BIT :: DuckDBPendingState
$mDUCKDB_TYPE_BIT :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_TYPE_BIT = 29

{-# COMPLETE
    DUCKDB_TYPE_INVALID
    , DUCKDB_TYPE_BOOLEAN
    , DUCKDB_TYPE_TINYINT
    , DUCKDB_TYPE_SMALLINT
    , DUCKDB_TYPE_INTEGER
    , DUCKDB_TYPE_BIGINT
    , DUCKDB_TYPE_UTINYINT
    , DUCKDB_TYPE_USMALLINT
    , DUCKDB_TYPE_UINTEGER
    , DUCKDB_TYPE_UBIGINT
    , DUCKDB_TYPE_FLOAT
    , DUCKDB_TYPE_DOUBLE
    , DUCKDB_TYPE_TIMESTAMP
    , DUCKDB_TYPE_DATE
    , DUCKDB_TYPE_TIME
    , DUCKDB_TYPE_INTERVAL
    , DUCKDB_TYPE_HUGEINT
    , DUCKDB_TYPE_VARCHAR
    , DUCKDB_TYPE_BLOB
    , DUCKDB_TYPE_DECIMAL
    , DUCKDB_TYPE_TIMESTAMP_S
    , DUCKDB_TYPE_TIMESTAMP_MS
    , DUCKDB_TYPE_TIMESTAMP_NS
    , DUCKDB_TYPE_ENUM
    , DUCKDB_TYPE_LIST
    , DUCKDB_TYPE_STRUCT
    , DUCKDB_TYPE_MAP
    , DUCKDB_TYPE_UUID
    , DUCKDB_TYPE_UNION
    , DUCKDB_TYPE_BIT ::
        DuckDBType
    #-}

type DuckDBDate = Int32 -- days

data DuckDBDateStruct = DuckDBDateStruct
    { DuckDBDateStruct -> DuckDBPendingState
year :: Int32
    , DuckDBDateStruct -> Int8
month :: Int8
    , DuckDBDateStruct -> Int8
day :: Int8
    }
    deriving (DuckDBDateStruct -> DuckDBDateStruct -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBDateStruct -> DuckDBDateStruct -> Bool
$c/= :: DuckDBDateStruct -> DuckDBDateStruct -> Bool
== :: DuckDBDateStruct -> DuckDBDateStruct -> Bool
$c== :: DuckDBDateStruct -> DuckDBDateStruct -> Bool
Eq, Int -> DuckDBDateStruct -> ShowS
[DuckDBDateStruct] -> ShowS
DuckDBDateStruct -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DuckDBDateStruct] -> ShowS
$cshowList :: [DuckDBDateStruct] -> ShowS
show :: DuckDBDateStruct -> String
$cshow :: DuckDBDateStruct -> String
showsPrec :: Int -> DuckDBDateStruct -> ShowS
$cshowsPrec :: Int -> DuckDBDateStruct -> ShowS
Show)

{- FOURMOLU_DISABLE -}

instance Storable DuckDBDateStruct where
    sizeOf :: DuckDBDateStruct -> Int
sizeOf DuckDBDateStruct
_ = ((Int
8))
{-# LINE 161 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    alignment _ = alignment (undefined :: CInt)
    peek :: Ptr DuckDBDateStruct -> IO DuckDBDateStruct
peek Ptr DuckDBDateStruct
ptr =
        DuckDBPendingState -> Int8 -> Int8 -> DuckDBDateStruct
DuckDBDateStruct
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((\Ptr DuckDBDateStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBDateStruct
hsc_ptr Int
0)) Ptr DuckDBDateStruct
ptr
{-# LINE 165 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBDateStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBDateStruct
hsc_ptr Int
4)) Ptr DuckDBDateStruct
ptr
{-# LINE 166 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBDateStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBDateStruct
hsc_ptr Int
5)) Ptr DuckDBDateStruct
ptr
{-# LINE 167 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    poke ptr (DuckDBDateStruct year month day) = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) ptr year
{-# LINE 169 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 4)) ptr month
{-# LINE 170 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 5)) ptr day
{-# LINE 171 "src/Database/DuckDB/Internal/FFI.hsc" #-}

{- FOURMOLU_ENABLE -}

type DuckDBTime = Int64 -- microseconds

data DuckDBTimeStruct = DuckDBTimeStruct
    { DuckDBTimeStruct -> Int8
hour :: Int8
    , DuckDBTimeStruct -> Int8
min :: Int8
    , DuckDBTimeStruct -> Int8
sec :: Int8
    , DuckDBTimeStruct -> DuckDBPendingState
micros :: Int32
    }
    deriving (DuckDBTimeStruct -> DuckDBTimeStruct -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBTimeStruct -> DuckDBTimeStruct -> Bool
$c/= :: DuckDBTimeStruct -> DuckDBTimeStruct -> Bool
== :: DuckDBTimeStruct -> DuckDBTimeStruct -> Bool
$c== :: DuckDBTimeStruct -> DuckDBTimeStruct -> Bool
Eq, Int -> DuckDBTimeStruct -> ShowS
[DuckDBTimeStruct] -> ShowS
DuckDBTimeStruct -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DuckDBTimeStruct] -> ShowS
$cshowList :: [DuckDBTimeStruct] -> ShowS
show :: DuckDBTimeStruct -> String
$cshow :: DuckDBTimeStruct -> String
showsPrec :: Int -> DuckDBTimeStruct -> ShowS
$cshowsPrec :: Int -> DuckDBTimeStruct -> ShowS
Show)

{- FOURMOLU_DISABLE -}

instance Storable DuckDBTimeStruct where
    sizeOf :: DuckDBTimeStruct -> Int
sizeOf DuckDBTimeStruct
_ = ((Int
8))
{-# LINE 188 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    alignment _ = alignment (undefined :: CInt)
    peek :: Ptr DuckDBTimeStruct -> IO DuckDBTimeStruct
peek Ptr DuckDBTimeStruct
ptr =
        Int8 -> Int8 -> Int8 -> DuckDBPendingState -> DuckDBTimeStruct
DuckDBTimeStruct
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((\Ptr DuckDBTimeStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBTimeStruct
hsc_ptr Int
0)) Ptr DuckDBTimeStruct
ptr
{-# LINE 192 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBTimeStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBTimeStruct
hsc_ptr Int
1)) Ptr DuckDBTimeStruct
ptr
{-# LINE 193 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBTimeStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBTimeStruct
hsc_ptr Int
2)) Ptr DuckDBTimeStruct
ptr
{-# LINE 194 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBTimeStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBTimeStruct
hsc_ptr Int
4)) Ptr DuckDBTimeStruct
ptr
{-# LINE 195 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    poke ptr (DuckDBTimeStruct hour minute sec micros) = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) ptr hour
{-# LINE 197 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 1)) ptr minute
{-# LINE 198 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 2)) ptr sec
{-# LINE 199 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 4)) ptr micros
{-# LINE 200 "src/Database/DuckDB/Internal/FFI.hsc" #-}

{- FOURMOLU_ENABLE -}

type DuckDBTimestamp = Int64 -- microseconds

data DuckDBTimestampStruct = DuckDBTimestampStruct
    { DuckDBTimestampStruct -> DuckDBDateStruct
date :: DuckDBDateStruct
    , DuckDBTimestampStruct -> DuckDBTimeStruct
time :: DuckDBTimeStruct
    }
    deriving (DuckDBTimestampStruct -> DuckDBTimestampStruct -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBTimestampStruct -> DuckDBTimestampStruct -> Bool
$c/= :: DuckDBTimestampStruct -> DuckDBTimestampStruct -> Bool
== :: DuckDBTimestampStruct -> DuckDBTimestampStruct -> Bool
$c== :: DuckDBTimestampStruct -> DuckDBTimestampStruct -> Bool
Eq, Int -> DuckDBTimestampStruct -> ShowS
[DuckDBTimestampStruct] -> ShowS
DuckDBTimestampStruct -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DuckDBTimestampStruct] -> ShowS
$cshowList :: [DuckDBTimestampStruct] -> ShowS
show :: DuckDBTimestampStruct -> String
$cshow :: DuckDBTimestampStruct -> String
showsPrec :: Int -> DuckDBTimestampStruct -> ShowS
$cshowsPrec :: Int -> DuckDBTimestampStruct -> ShowS
Show)

{- FOURMOLU_DISABLE -}

instance Storable DuckDBTimestampStruct where
    sizeOf :: DuckDBTimestampStruct -> Int
sizeOf DuckDBTimestampStruct
_ = ((Int
16))
{-# LINE 215 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    alignment _ = alignment (undefined :: CInt)
    peek :: Ptr DuckDBTimestampStruct -> IO DuckDBTimestampStruct
peek Ptr DuckDBTimestampStruct
ptr =
        DuckDBDateStruct -> DuckDBTimeStruct -> DuckDBTimestampStruct
DuckDBTimestampStruct
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((\Ptr DuckDBTimestampStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBTimestampStruct
hsc_ptr Int
0)) Ptr DuckDBTimestampStruct
ptr
{-# LINE 219 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBTimestampStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBTimestampStruct
hsc_ptr Int
8)) Ptr DuckDBTimestampStruct
ptr
{-# LINE 220 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    poke ptr (DuckDBTimestampStruct date time) = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) ptr date
{-# LINE 222 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 8)) ptr time
{-# LINE 223 "src/Database/DuckDB/Internal/FFI.hsc" #-}

{- FOURMOLU_ENABLE -}

data DuckDBIntervalStruct = DuckDBIntervalStruct
    { DuckDBIntervalStruct -> DuckDBPendingState
months :: Int32
    , DuckDBIntervalStruct -> DuckDBPendingState
days :: Int32
    , DuckDBIntervalStruct -> Int64
micros :: Int64
    }
    deriving (DuckDBIntervalStruct -> DuckDBIntervalStruct -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBIntervalStruct -> DuckDBIntervalStruct -> Bool
$c/= :: DuckDBIntervalStruct -> DuckDBIntervalStruct -> Bool
== :: DuckDBIntervalStruct -> DuckDBIntervalStruct -> Bool
$c== :: DuckDBIntervalStruct -> DuckDBIntervalStruct -> Bool
Eq, Int -> DuckDBIntervalStruct -> ShowS
[DuckDBIntervalStruct] -> ShowS
DuckDBIntervalStruct -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DuckDBIntervalStruct] -> ShowS
$cshowList :: [DuckDBIntervalStruct] -> ShowS
show :: DuckDBIntervalStruct -> String
$cshow :: DuckDBIntervalStruct -> String
showsPrec :: Int -> DuckDBIntervalStruct -> ShowS
$cshowsPrec :: Int -> DuckDBIntervalStruct -> ShowS
Show)

{- FOURMOLU_DISABLE -}

instance Storable DuckDBIntervalStruct where
    sizeOf :: DuckDBIntervalStruct -> Int
sizeOf DuckDBIntervalStruct
_ = ((Int
16))
{-# LINE 237 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    alignment _ = alignment (undefined :: CInt)
    peek :: Ptr DuckDBIntervalStruct -> IO DuckDBIntervalStruct
peek Ptr DuckDBIntervalStruct
ptr =
        DuckDBPendingState
-> DuckDBPendingState -> Int64 -> DuckDBIntervalStruct
DuckDBIntervalStruct
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((\Ptr DuckDBIntervalStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBIntervalStruct
hsc_ptr Int
0)) Ptr DuckDBIntervalStruct
ptr
{-# LINE 241 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBIntervalStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBIntervalStruct
hsc_ptr Int
4)) Ptr DuckDBIntervalStruct
ptr
{-# LINE 242 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBIntervalStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBIntervalStruct
hsc_ptr Int
8)) Ptr DuckDBIntervalStruct
ptr
{-# LINE 243 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    poke ptr (DuckDBIntervalStruct months days micros) = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) ptr months
{-# LINE 245 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 4)) ptr days
{-# LINE 246 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 8)) ptr micros
{-# LINE 247 "src/Database/DuckDB/Internal/FFI.hsc" #-}

{- FOURMOLU_ENABLE -}

data DuckDBHugeIntStruct = DuckDBHugeIntStruct
    { DuckDBHugeIntStruct -> Word64
lower :: Word64
    , DuckDBHugeIntStruct -> Int64
upper :: Int64
    }
    deriving (DuckDBHugeIntStruct -> DuckDBHugeIntStruct -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBHugeIntStruct -> DuckDBHugeIntStruct -> Bool
$c/= :: DuckDBHugeIntStruct -> DuckDBHugeIntStruct -> Bool
== :: DuckDBHugeIntStruct -> DuckDBHugeIntStruct -> Bool
$c== :: DuckDBHugeIntStruct -> DuckDBHugeIntStruct -> Bool
Eq, Int -> DuckDBHugeIntStruct -> ShowS
[DuckDBHugeIntStruct] -> ShowS
DuckDBHugeIntStruct -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DuckDBHugeIntStruct] -> ShowS
$cshowList :: [DuckDBHugeIntStruct] -> ShowS
show :: DuckDBHugeIntStruct -> String
$cshow :: DuckDBHugeIntStruct -> String
showsPrec :: Int -> DuckDBHugeIntStruct -> ShowS
$cshowsPrec :: Int -> DuckDBHugeIntStruct -> ShowS
Show)

{- FOURMOLU_DISABLE -}

instance Storable DuckDBHugeIntStruct where
    sizeOf :: DuckDBHugeIntStruct -> Int
sizeOf DuckDBHugeIntStruct
_ = ((Int
16))
{-# LINE 260 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    alignment _ = alignment (undefined :: CInt)
    peek :: Ptr DuckDBHugeIntStruct -> IO DuckDBHugeIntStruct
peek Ptr DuckDBHugeIntStruct
ptr =
        Word64 -> Int64 -> DuckDBHugeIntStruct
DuckDBHugeIntStruct
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((\Ptr DuckDBHugeIntStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBHugeIntStruct
hsc_ptr Int
0)) Ptr DuckDBHugeIntStruct
ptr
{-# LINE 264 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBHugeIntStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBHugeIntStruct
hsc_ptr Int
8)) Ptr DuckDBHugeIntStruct
ptr
{-# LINE 265 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    poke ptr (DuckDBHugeIntStruct lower upper) = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) ptr lower
{-# LINE 267 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 8)) ptr upper
{-# LINE 268 "src/Database/DuckDB/Internal/FFI.hsc" #-}

{- FOURMOLU_ENABLE -}

data DuckDBDecimalStruct = DuckDBDecimalStruct
    { DuckDBDecimalStruct -> Word8
width :: Word8
    , DuckDBDecimalStruct -> Word8
scale :: Word8
    , DuckDBDecimalStruct -> DuckDBHugeIntStruct
value :: DuckDBHugeIntStruct
    }
    deriving (DuckDBDecimalStruct -> DuckDBDecimalStruct -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBDecimalStruct -> DuckDBDecimalStruct -> Bool
$c/= :: DuckDBDecimalStruct -> DuckDBDecimalStruct -> Bool
== :: DuckDBDecimalStruct -> DuckDBDecimalStruct -> Bool
$c== :: DuckDBDecimalStruct -> DuckDBDecimalStruct -> Bool
Eq, Int -> DuckDBDecimalStruct -> ShowS
[DuckDBDecimalStruct] -> ShowS
DuckDBDecimalStruct -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DuckDBDecimalStruct] -> ShowS
$cshowList :: [DuckDBDecimalStruct] -> ShowS
show :: DuckDBDecimalStruct -> String
$cshow :: DuckDBDecimalStruct -> String
showsPrec :: Int -> DuckDBDecimalStruct -> ShowS
$cshowsPrec :: Int -> DuckDBDecimalStruct -> ShowS
Show)

{- FOURMOLU_DISABLE -}

instance Storable DuckDBDecimalStruct where
    sizeOf :: DuckDBDecimalStruct -> Int
sizeOf DuckDBDecimalStruct
_ = ((Int
24))
{-# LINE 282 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    alignment _ = alignment (undefined :: CInt)
    peek :: Ptr DuckDBDecimalStruct -> IO DuckDBDecimalStruct
peek Ptr DuckDBDecimalStruct
ptr =
        Word8 -> Word8 -> DuckDBHugeIntStruct -> DuckDBDecimalStruct
DuckDBDecimalStruct
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((\Ptr DuckDBDecimalStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBDecimalStruct
hsc_ptr Int
0)) Ptr DuckDBDecimalStruct
ptr
{-# LINE 286 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBDecimalStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBDecimalStruct
hsc_ptr Int
1)) Ptr DuckDBDecimalStruct
ptr
{-# LINE 287 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBDecimalStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBDecimalStruct
hsc_ptr Int
8)) Ptr DuckDBDecimalStruct
ptr
{-# LINE 288 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    poke ptr (DuckDBDecimalStruct width scale value) = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) ptr width
{-# LINE 290 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 1)) ptr scale
{-# LINE 291 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 8)) ptr value
{-# LINE 292 "src/Database/DuckDB/Internal/FFI.hsc" #-}

{- FOURMOLU_ENABLE -}

data DuckDBStringStruct = DuckDBStringStruct
    { DuckDBStringStruct -> CString
data_ :: CString
    , DuckDBStringStruct -> Word64
size :: DuckDBIndexType
    }
    deriving (DuckDBStringStruct -> DuckDBStringStruct -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBStringStruct -> DuckDBStringStruct -> Bool
$c/= :: DuckDBStringStruct -> DuckDBStringStruct -> Bool
== :: DuckDBStringStruct -> DuckDBStringStruct -> Bool
$c== :: DuckDBStringStruct -> DuckDBStringStruct -> Bool
Eq, Int -> DuckDBStringStruct -> ShowS
[DuckDBStringStruct] -> ShowS
DuckDBStringStruct -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DuckDBStringStruct] -> ShowS
$cshowList :: [DuckDBStringStruct] -> ShowS
show :: DuckDBStringStruct -> String
$cshow :: DuckDBStringStruct -> String
showsPrec :: Int -> DuckDBStringStruct -> ShowS
$cshowsPrec :: Int -> DuckDBStringStruct -> ShowS
Show)

{- FOURMOLU_DISABLE -}

instance Storable DuckDBStringStruct where
    sizeOf :: DuckDBStringStruct -> Int
sizeOf DuckDBStringStruct
_ = ((Int
16))
{-# LINE 305 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    alignment _ = alignment (undefined :: CInt)
    peek :: Ptr DuckDBStringStruct -> IO DuckDBStringStruct
peek Ptr DuckDBStringStruct
ptr =
        CString -> Word64 -> DuckDBStringStruct
DuckDBStringStruct
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((\Ptr DuckDBStringStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBStringStruct
hsc_ptr Int
0)) Ptr DuckDBStringStruct
ptr
{-# LINE 309 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBStringStruct
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBStringStruct
hsc_ptr Int
8)) Ptr DuckDBStringStruct
ptr
{-# LINE 310 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    poke ptr (DuckDBStringStruct data_ size) = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) ptr data_
{-# LINE 312 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 8)) ptr size
{-# LINE 313 "src/Database/DuckDB/Internal/FFI.hsc" #-}

{- FOURMOLU_ENABLE -}

-- typedef struct {
-- 	union {
-- 		struct {
-- 			uint32_t length;
-- 			char prefix[4];
-- 			char *ptr;
-- 		} pointer;
-- 		struct {
-- 			uint32_t length;
-- 			char inlined[12];
-- 		} inlined;
-- 	} value;
-- } duckdb_string_t;

data DuckDBBlob = DuckDBBlob
    { DuckDBBlob -> Ptr ()
data_ :: Ptr ()
    , DuckDBBlob -> Word64
size :: DuckDBIndexType
    }
    deriving (DuckDBBlob -> DuckDBBlob -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBBlob -> DuckDBBlob -> Bool
$c/= :: DuckDBBlob -> DuckDBBlob -> Bool
== :: DuckDBBlob -> DuckDBBlob -> Bool
$c== :: DuckDBBlob -> DuckDBBlob -> Bool
Eq, Int -> DuckDBBlob -> ShowS
[DuckDBBlob] -> ShowS
DuckDBBlob -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DuckDBBlob] -> ShowS
$cshowList :: [DuckDBBlob] -> ShowS
show :: DuckDBBlob -> String
$cshow :: DuckDBBlob -> String
showsPrec :: Int -> DuckDBBlob -> ShowS
$cshowsPrec :: Int -> DuckDBBlob -> ShowS
Show)

{- FOURMOLU_DISABLE -}

instance Storable DuckDBBlob where
    sizeOf :: DuckDBBlob -> Int
sizeOf DuckDBBlob
_ = ((Int
16))
{-# LINE 340 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    alignment _ = alignment (undefined :: CInt)
    peek :: Ptr DuckDBBlob -> IO DuckDBBlob
peek Ptr DuckDBBlob
ptr =
        Ptr () -> Word64 -> DuckDBBlob
DuckDBBlob
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((\Ptr DuckDBBlob
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBBlob
hsc_ptr Int
0)) Ptr DuckDBBlob
ptr
{-# LINE 344 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBBlob
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBBlob
hsc_ptr Int
8)) Ptr DuckDBBlob
ptr
{-# LINE 345 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    poke ptr (DuckDBBlob data_ size) = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) ptr data_
{-# LINE 347 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 8)) ptr size
{-# LINE 348 "src/Database/DuckDB/Internal/FFI.hsc" #-}

{- FOURMOLU_ENABLE -}

data DuckDBListEntry = DuckDBListEntry
    { DuckDBListEntry -> Word64
offset :: Word64
    , DuckDBListEntry -> Word64
length :: Word64
    }
    deriving (DuckDBListEntry -> DuckDBListEntry -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBListEntry -> DuckDBListEntry -> Bool
$c/= :: DuckDBListEntry -> DuckDBListEntry -> Bool
== :: DuckDBListEntry -> DuckDBListEntry -> Bool
$c== :: DuckDBListEntry -> DuckDBListEntry -> Bool
Eq, Int -> DuckDBListEntry -> ShowS
[DuckDBListEntry] -> ShowS
DuckDBListEntry -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DuckDBListEntry] -> ShowS
$cshowList :: [DuckDBListEntry] -> ShowS
show :: DuckDBListEntry -> String
$cshow :: DuckDBListEntry -> String
showsPrec :: Int -> DuckDBListEntry -> ShowS
$cshowsPrec :: Int -> DuckDBListEntry -> ShowS
Show)

{- FOURMOLU_DISABLE -}

instance Storable DuckDBListEntry where
    sizeOf :: DuckDBListEntry -> Int
sizeOf DuckDBListEntry
_ = ((Int
16))
{-# LINE 361 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    alignment _ = alignment (undefined :: CInt)
    peek :: Ptr DuckDBListEntry -> IO DuckDBListEntry
peek Ptr DuckDBListEntry
ptr =
        Word64 -> Word64 -> DuckDBListEntry
DuckDBListEntry
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((\Ptr DuckDBListEntry
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBListEntry
hsc_ptr Int
0)) Ptr DuckDBListEntry
ptr
{-# LINE 365 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBListEntry
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBListEntry
hsc_ptr Int
8)) Ptr DuckDBListEntry
ptr
{-# LINE 366 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    poke ptr (DuckDBListEntry offset length_) = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) ptr offset
{-# LINE 368 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 8)) ptr length_
{-# LINE 369 "src/Database/DuckDB/Internal/FFI.hsc" #-}

{- FOURMOLU_ENABLE -}

data DuckDBColumn = DuckDBColumn
    { DuckDBColumn -> Ptr ()
data_ :: Ptr ()
    , DuckDBColumn -> Ptr Bool
nullmask :: Ptr Bool
    , DuckDBColumn -> DuckDBPendingState
type_ :: DuckDBType
    , DuckDBColumn -> CString
name :: CString
    , DuckDBColumn -> Ptr ()
internal_data :: Ptr ()
    }
    deriving (DuckDBColumn -> DuckDBColumn -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBColumn -> DuckDBColumn -> Bool
$c/= :: DuckDBColumn -> DuckDBColumn -> Bool
== :: DuckDBColumn -> DuckDBColumn -> Bool
$c== :: DuckDBColumn -> DuckDBColumn -> Bool
Eq, Int -> DuckDBColumn -> ShowS
[DuckDBColumn] -> ShowS
DuckDBColumn -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DuckDBColumn] -> ShowS
$cshowList :: [DuckDBColumn] -> ShowS
show :: DuckDBColumn -> String
$cshow :: DuckDBColumn -> String
showsPrec :: Int -> DuckDBColumn -> ShowS
$cshowsPrec :: Int -> DuckDBColumn -> ShowS
Show)

{- FOURMOLU_DISABLE -}

instance Storable DuckDBColumn where
    sizeOf :: DuckDBColumn -> Int
sizeOf DuckDBColumn
_ = ((Int
40))
{-# LINE 385 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    alignment _ = alignment (undefined :: CInt)
    peek :: Ptr DuckDBColumn -> IO DuckDBColumn
peek Ptr DuckDBColumn
ptr =
        Ptr ()
-> Ptr Bool
-> DuckDBPendingState
-> CString
-> Ptr ()
-> DuckDBColumn
DuckDBColumn
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((\Ptr DuckDBColumn
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBColumn
hsc_ptr Int
0)) Ptr DuckDBColumn
ptr
{-# LINE 389 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBColumn
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBColumn
hsc_ptr Int
8)) Ptr DuckDBColumn
ptr
{-# LINE 390 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBColumn
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBColumn
hsc_ptr Int
16)) Ptr DuckDBColumn
ptr
{-# LINE 391 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBColumn
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBColumn
hsc_ptr Int
24)) Ptr DuckDBColumn
ptr
{-# LINE 392 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBColumn
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBColumn
hsc_ptr Int
32)) Ptr DuckDBColumn
ptr
{-# LINE 393 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    poke ptr (DuckDBColumn data_ nullmask type_ name internal_data) = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) ptr data_
{-# LINE 395 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 8)) ptr nullmask
{-# LINE 396 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 16)) ptr type_
{-# LINE 397 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 24)) ptr name
{-# LINE 398 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 32)) ptr internal_data
{-# LINE 399 "src/Database/DuckDB/Internal/FFI.hsc" #-}

{- FOURMOLU_ENABLE -}

data DuckDBResult = DuckDBResult
    { DuckDBResult -> Word64
column_count :: DuckDBIndexType
    , DuckDBResult -> Word64
row_count :: DuckDBIndexType
    , DuckDBResult -> Word64
rows_changed :: DuckDBIndexType
    , DuckDBResult -> Ptr DuckDBColumn
columns :: Ptr DuckDBColumn
    , DuckDBResult -> CString
error_message :: CString
    , DuckDBResult -> Ptr ()
internal_data :: Ptr ()
    }
    deriving (DuckDBResult -> DuckDBResult -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBResult -> DuckDBResult -> Bool
$c/= :: DuckDBResult -> DuckDBResult -> Bool
== :: DuckDBResult -> DuckDBResult -> Bool
$c== :: DuckDBResult -> DuckDBResult -> Bool
Eq, Int -> DuckDBResult -> ShowS
[DuckDBResult] -> ShowS
DuckDBResult -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DuckDBResult] -> ShowS
$cshowList :: [DuckDBResult] -> ShowS
show :: DuckDBResult -> String
$cshow :: DuckDBResult -> String
showsPrec :: Int -> DuckDBResult -> ShowS
$cshowsPrec :: Int -> DuckDBResult -> ShowS
Show)

{- FOURMOLU_DISABLE -}

instance Storable DuckDBResult where
    sizeOf :: DuckDBResult -> Int
sizeOf DuckDBResult
_ = ((Int
48))
{-# LINE 416 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    alignment _ = alignment (undefined :: CInt)
    peek :: Ptr DuckDBResult -> IO DuckDBResult
peek Ptr DuckDBResult
ptr =
        Word64
-> Word64
-> Word64
-> Ptr DuckDBColumn
-> CString
-> Ptr ()
-> DuckDBResult
DuckDBResult
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((\Ptr DuckDBResult
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBResult
hsc_ptr Int
0)) Ptr DuckDBResult
ptr
{-# LINE 420 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBResult
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBResult
hsc_ptr Int
8)) Ptr DuckDBResult
ptr
{-# LINE 421 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBResult
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBResult
hsc_ptr Int
16)) Ptr DuckDBResult
ptr
{-# LINE 422 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBResult
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBResult
hsc_ptr Int
24)) Ptr DuckDBResult
ptr
{-# LINE 423 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBResult
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBResult
hsc_ptr Int
32)) Ptr DuckDBResult
ptr
{-# LINE 424 "src/Database/DuckDB/Internal/FFI.hsc" #-}
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\Ptr DuckDBResult
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr DuckDBResult
hsc_ptr Int
40)) Ptr DuckDBResult
ptr
{-# LINE 425 "src/Database/DuckDB/Internal/FFI.hsc" #-}
    poke ptr (DuckDBResult column_count row_count rows_changed columns error_message internal_data) = do
        ((\hsc_ptr -> pokeByteOff hsc_ptr 0)) ptr column_count
{-# LINE 427 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 8)) ptr row_count
{-# LINE 428 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 16)) ptr rows_changed
{-# LINE 429 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 24)) ptr columns
{-# LINE 430 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 32)) ptr error_message
{-# LINE 431 "src/Database/DuckDB/Internal/FFI.hsc" #-}
        ((\hsc_ptr -> pokeByteOff hsc_ptr 40)) ptr internal_data
{-# LINE 432 "src/Database/DuckDB/Internal/FFI.hsc" #-}

{- FOURMOLU_ENABLE -}

newtype DuckDBDatabase = DuckDBDatabase (Ptr ()) deriving (DuckDBDatabase -> DuckDBDatabase -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBDatabase -> DuckDBDatabase -> Bool
$c/= :: DuckDBDatabase -> DuckDBDatabase -> Bool
== :: DuckDBDatabase -> DuckDBDatabase -> Bool
$c== :: DuckDBDatabase -> DuckDBDatabase -> Bool
Eq, Ptr DuckDBDatabase -> IO DuckDBDatabase
Ptr DuckDBDatabase -> Int -> IO DuckDBDatabase
Ptr DuckDBDatabase -> Int -> DuckDBDatabase -> IO ()
Ptr DuckDBDatabase -> DuckDBDatabase -> IO ()
DuckDBDatabase -> Int
forall b. Ptr b -> Int -> IO DuckDBDatabase
forall b. Ptr b -> Int -> DuckDBDatabase -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBDatabase -> DuckDBDatabase -> IO ()
$cpoke :: Ptr DuckDBDatabase -> DuckDBDatabase -> IO ()
peek :: Ptr DuckDBDatabase -> IO DuckDBDatabase
$cpeek :: Ptr DuckDBDatabase -> IO DuckDBDatabase
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBDatabase -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBDatabase -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBDatabase
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBDatabase
pokeElemOff :: Ptr DuckDBDatabase -> Int -> DuckDBDatabase -> IO ()
$cpokeElemOff :: Ptr DuckDBDatabase -> Int -> DuckDBDatabase -> IO ()
peekElemOff :: Ptr DuckDBDatabase -> Int -> IO DuckDBDatabase
$cpeekElemOff :: Ptr DuckDBDatabase -> Int -> IO DuckDBDatabase
alignment :: DuckDBDatabase -> Int
$calignment :: DuckDBDatabase -> Int
sizeOf :: DuckDBDatabase -> Int
$csizeOf :: DuckDBDatabase -> Int
Storable)

newtype DuckDBConnection = DuckDBConnection (Ptr ()) deriving (DuckDBConnection -> DuckDBConnection -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBConnection -> DuckDBConnection -> Bool
$c/= :: DuckDBConnection -> DuckDBConnection -> Bool
== :: DuckDBConnection -> DuckDBConnection -> Bool
$c== :: DuckDBConnection -> DuckDBConnection -> Bool
Eq, Ptr DuckDBConnection -> IO DuckDBConnection
Ptr DuckDBConnection -> Int -> IO DuckDBConnection
Ptr DuckDBConnection -> Int -> DuckDBConnection -> IO ()
Ptr DuckDBConnection -> DuckDBConnection -> IO ()
DuckDBConnection -> Int
forall b. Ptr b -> Int -> IO DuckDBConnection
forall b. Ptr b -> Int -> DuckDBConnection -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBConnection -> DuckDBConnection -> IO ()
$cpoke :: Ptr DuckDBConnection -> DuckDBConnection -> IO ()
peek :: Ptr DuckDBConnection -> IO DuckDBConnection
$cpeek :: Ptr DuckDBConnection -> IO DuckDBConnection
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBConnection -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBConnection -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBConnection
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBConnection
pokeElemOff :: Ptr DuckDBConnection -> Int -> DuckDBConnection -> IO ()
$cpokeElemOff :: Ptr DuckDBConnection -> Int -> DuckDBConnection -> IO ()
peekElemOff :: Ptr DuckDBConnection -> Int -> IO DuckDBConnection
$cpeekElemOff :: Ptr DuckDBConnection -> Int -> IO DuckDBConnection
alignment :: DuckDBConnection -> Int
$calignment :: DuckDBConnection -> Int
sizeOf :: DuckDBConnection -> Int
$csizeOf :: DuckDBConnection -> Int
Storable)

newtype DuckDBPreparedStatement = DuckDBPreparedStatement (Ptr ())
    deriving (DuckDBPreparedStatement -> DuckDBPreparedStatement -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBPreparedStatement -> DuckDBPreparedStatement -> Bool
$c/= :: DuckDBPreparedStatement -> DuckDBPreparedStatement -> Bool
== :: DuckDBPreparedStatement -> DuckDBPreparedStatement -> Bool
$c== :: DuckDBPreparedStatement -> DuckDBPreparedStatement -> Bool
Eq, Ptr DuckDBPreparedStatement -> IO DuckDBPreparedStatement
Ptr DuckDBPreparedStatement -> Int -> IO DuckDBPreparedStatement
Ptr DuckDBPreparedStatement
-> Int -> DuckDBPreparedStatement -> IO ()
Ptr DuckDBPreparedStatement -> DuckDBPreparedStatement -> IO ()
DuckDBPreparedStatement -> Int
forall b. Ptr b -> Int -> IO DuckDBPreparedStatement
forall b. Ptr b -> Int -> DuckDBPreparedStatement -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBPreparedStatement -> DuckDBPreparedStatement -> IO ()
$cpoke :: Ptr DuckDBPreparedStatement -> DuckDBPreparedStatement -> IO ()
peek :: Ptr DuckDBPreparedStatement -> IO DuckDBPreparedStatement
$cpeek :: Ptr DuckDBPreparedStatement -> IO DuckDBPreparedStatement
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBPreparedStatement -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBPreparedStatement -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBPreparedStatement
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBPreparedStatement
pokeElemOff :: Ptr DuckDBPreparedStatement
-> Int -> DuckDBPreparedStatement -> IO ()
$cpokeElemOff :: Ptr DuckDBPreparedStatement
-> Int -> DuckDBPreparedStatement -> IO ()
peekElemOff :: Ptr DuckDBPreparedStatement -> Int -> IO DuckDBPreparedStatement
$cpeekElemOff :: Ptr DuckDBPreparedStatement -> Int -> IO DuckDBPreparedStatement
alignment :: DuckDBPreparedStatement -> Int
$calignment :: DuckDBPreparedStatement -> Int
sizeOf :: DuckDBPreparedStatement -> Int
$csizeOf :: DuckDBPreparedStatement -> Int
Storable)

newtype DuckDBExtractedStatements = DuckDBExtractedStatements (Ptr ())
    deriving (DuckDBExtractedStatements -> DuckDBExtractedStatements -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBExtractedStatements -> DuckDBExtractedStatements -> Bool
$c/= :: DuckDBExtractedStatements -> DuckDBExtractedStatements -> Bool
== :: DuckDBExtractedStatements -> DuckDBExtractedStatements -> Bool
$c== :: DuckDBExtractedStatements -> DuckDBExtractedStatements -> Bool
Eq, Ptr DuckDBExtractedStatements -> IO DuckDBExtractedStatements
Ptr DuckDBExtractedStatements
-> Int -> IO DuckDBExtractedStatements
Ptr DuckDBExtractedStatements
-> Int -> DuckDBExtractedStatements -> IO ()
Ptr DuckDBExtractedStatements -> DuckDBExtractedStatements -> IO ()
DuckDBExtractedStatements -> Int
forall b. Ptr b -> Int -> IO DuckDBExtractedStatements
forall b. Ptr b -> Int -> DuckDBExtractedStatements -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBExtractedStatements -> DuckDBExtractedStatements -> IO ()
$cpoke :: Ptr DuckDBExtractedStatements -> DuckDBExtractedStatements -> IO ()
peek :: Ptr DuckDBExtractedStatements -> IO DuckDBExtractedStatements
$cpeek :: Ptr DuckDBExtractedStatements -> IO DuckDBExtractedStatements
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBExtractedStatements -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBExtractedStatements -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBExtractedStatements
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBExtractedStatements
pokeElemOff :: Ptr DuckDBExtractedStatements
-> Int -> DuckDBExtractedStatements -> IO ()
$cpokeElemOff :: Ptr DuckDBExtractedStatements
-> Int -> DuckDBExtractedStatements -> IO ()
peekElemOff :: Ptr DuckDBExtractedStatements
-> Int -> IO DuckDBExtractedStatements
$cpeekElemOff :: Ptr DuckDBExtractedStatements
-> Int -> IO DuckDBExtractedStatements
alignment :: DuckDBExtractedStatements -> Int
$calignment :: DuckDBExtractedStatements -> Int
sizeOf :: DuckDBExtractedStatements -> Int
$csizeOf :: DuckDBExtractedStatements -> Int
Storable)

newtype DuckDBPendingResult = DuckDBPendingResult (Ptr ())
    deriving (DuckDBPendingResult -> DuckDBPendingResult -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBPendingResult -> DuckDBPendingResult -> Bool
$c/= :: DuckDBPendingResult -> DuckDBPendingResult -> Bool
== :: DuckDBPendingResult -> DuckDBPendingResult -> Bool
$c== :: DuckDBPendingResult -> DuckDBPendingResult -> Bool
Eq, Ptr DuckDBPendingResult -> IO DuckDBPendingResult
Ptr DuckDBPendingResult -> Int -> IO DuckDBPendingResult
Ptr DuckDBPendingResult -> Int -> DuckDBPendingResult -> IO ()
Ptr DuckDBPendingResult -> DuckDBPendingResult -> IO ()
DuckDBPendingResult -> Int
forall b. Ptr b -> Int -> IO DuckDBPendingResult
forall b. Ptr b -> Int -> DuckDBPendingResult -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBPendingResult -> DuckDBPendingResult -> IO ()
$cpoke :: Ptr DuckDBPendingResult -> DuckDBPendingResult -> IO ()
peek :: Ptr DuckDBPendingResult -> IO DuckDBPendingResult
$cpeek :: Ptr DuckDBPendingResult -> IO DuckDBPendingResult
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBPendingResult -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBPendingResult -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBPendingResult
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBPendingResult
pokeElemOff :: Ptr DuckDBPendingResult -> Int -> DuckDBPendingResult -> IO ()
$cpokeElemOff :: Ptr DuckDBPendingResult -> Int -> DuckDBPendingResult -> IO ()
peekElemOff :: Ptr DuckDBPendingResult -> Int -> IO DuckDBPendingResult
$cpeekElemOff :: Ptr DuckDBPendingResult -> Int -> IO DuckDBPendingResult
alignment :: DuckDBPendingResult -> Int
$calignment :: DuckDBPendingResult -> Int
sizeOf :: DuckDBPendingResult -> Int
$csizeOf :: DuckDBPendingResult -> Int
Storable)

newtype DuckDBAppender = DuckDBAppender (Ptr ()) deriving (DuckDBAppender -> DuckDBAppender -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBAppender -> DuckDBAppender -> Bool
$c/= :: DuckDBAppender -> DuckDBAppender -> Bool
== :: DuckDBAppender -> DuckDBAppender -> Bool
$c== :: DuckDBAppender -> DuckDBAppender -> Bool
Eq, Ptr DuckDBAppender -> IO DuckDBAppender
Ptr DuckDBAppender -> Int -> IO DuckDBAppender
Ptr DuckDBAppender -> Int -> DuckDBAppender -> IO ()
Ptr DuckDBAppender -> DuckDBAppender -> IO ()
DuckDBAppender -> Int
forall b. Ptr b -> Int -> IO DuckDBAppender
forall b. Ptr b -> Int -> DuckDBAppender -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBAppender -> DuckDBAppender -> IO ()
$cpoke :: Ptr DuckDBAppender -> DuckDBAppender -> IO ()
peek :: Ptr DuckDBAppender -> IO DuckDBAppender
$cpeek :: Ptr DuckDBAppender -> IO DuckDBAppender
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBAppender -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBAppender -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBAppender
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBAppender
pokeElemOff :: Ptr DuckDBAppender -> Int -> DuckDBAppender -> IO ()
$cpokeElemOff :: Ptr DuckDBAppender -> Int -> DuckDBAppender -> IO ()
peekElemOff :: Ptr DuckDBAppender -> Int -> IO DuckDBAppender
$cpeekElemOff :: Ptr DuckDBAppender -> Int -> IO DuckDBAppender
alignment :: DuckDBAppender -> Int
$calignment :: DuckDBAppender -> Int
sizeOf :: DuckDBAppender -> Int
$csizeOf :: DuckDBAppender -> Int
Storable)

newtype DuckDBArrow = DuckDBArrow (Ptr ()) deriving (DuckDBArrow -> DuckDBArrow -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBArrow -> DuckDBArrow -> Bool
$c/= :: DuckDBArrow -> DuckDBArrow -> Bool
== :: DuckDBArrow -> DuckDBArrow -> Bool
$c== :: DuckDBArrow -> DuckDBArrow -> Bool
Eq, Ptr DuckDBArrow -> IO DuckDBArrow
Ptr DuckDBArrow -> Int -> IO DuckDBArrow
Ptr DuckDBArrow -> Int -> DuckDBArrow -> IO ()
Ptr DuckDBArrow -> DuckDBArrow -> IO ()
DuckDBArrow -> Int
forall b. Ptr b -> Int -> IO DuckDBArrow
forall b. Ptr b -> Int -> DuckDBArrow -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBArrow -> DuckDBArrow -> IO ()
$cpoke :: Ptr DuckDBArrow -> DuckDBArrow -> IO ()
peek :: Ptr DuckDBArrow -> IO DuckDBArrow
$cpeek :: Ptr DuckDBArrow -> IO DuckDBArrow
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBArrow -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBArrow -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBArrow
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBArrow
pokeElemOff :: Ptr DuckDBArrow -> Int -> DuckDBArrow -> IO ()
$cpokeElemOff :: Ptr DuckDBArrow -> Int -> DuckDBArrow -> IO ()
peekElemOff :: Ptr DuckDBArrow -> Int -> IO DuckDBArrow
$cpeekElemOff :: Ptr DuckDBArrow -> Int -> IO DuckDBArrow
alignment :: DuckDBArrow -> Int
$calignment :: DuckDBArrow -> Int
sizeOf :: DuckDBArrow -> Int
$csizeOf :: DuckDBArrow -> Int
Storable)

newtype DuckDBConfig = DuckDBConfig (Ptr ()) deriving (DuckDBConfig -> DuckDBConfig -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBConfig -> DuckDBConfig -> Bool
$c/= :: DuckDBConfig -> DuckDBConfig -> Bool
== :: DuckDBConfig -> DuckDBConfig -> Bool
$c== :: DuckDBConfig -> DuckDBConfig -> Bool
Eq, Ptr DuckDBConfig -> IO DuckDBConfig
Ptr DuckDBConfig -> Int -> IO DuckDBConfig
Ptr DuckDBConfig -> Int -> DuckDBConfig -> IO ()
Ptr DuckDBConfig -> DuckDBConfig -> IO ()
DuckDBConfig -> Int
forall b. Ptr b -> Int -> IO DuckDBConfig
forall b. Ptr b -> Int -> DuckDBConfig -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBConfig -> DuckDBConfig -> IO ()
$cpoke :: Ptr DuckDBConfig -> DuckDBConfig -> IO ()
peek :: Ptr DuckDBConfig -> IO DuckDBConfig
$cpeek :: Ptr DuckDBConfig -> IO DuckDBConfig
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBConfig -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBConfig -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBConfig
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBConfig
pokeElemOff :: Ptr DuckDBConfig -> Int -> DuckDBConfig -> IO ()
$cpokeElemOff :: Ptr DuckDBConfig -> Int -> DuckDBConfig -> IO ()
peekElemOff :: Ptr DuckDBConfig -> Int -> IO DuckDBConfig
$cpeekElemOff :: Ptr DuckDBConfig -> Int -> IO DuckDBConfig
alignment :: DuckDBConfig -> Int
$calignment :: DuckDBConfig -> Int
sizeOf :: DuckDBConfig -> Int
$csizeOf :: DuckDBConfig -> Int
Storable)

newtype DuckDBArrowSchema = DuckDBArrowSchema (Ptr ()) deriving (DuckDBArrowSchema -> DuckDBArrowSchema -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBArrowSchema -> DuckDBArrowSchema -> Bool
$c/= :: DuckDBArrowSchema -> DuckDBArrowSchema -> Bool
== :: DuckDBArrowSchema -> DuckDBArrowSchema -> Bool
$c== :: DuckDBArrowSchema -> DuckDBArrowSchema -> Bool
Eq, Ptr DuckDBArrowSchema -> IO DuckDBArrowSchema
Ptr DuckDBArrowSchema -> Int -> IO DuckDBArrowSchema
Ptr DuckDBArrowSchema -> Int -> DuckDBArrowSchema -> IO ()
Ptr DuckDBArrowSchema -> DuckDBArrowSchema -> IO ()
DuckDBArrowSchema -> Int
forall b. Ptr b -> Int -> IO DuckDBArrowSchema
forall b. Ptr b -> Int -> DuckDBArrowSchema -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBArrowSchema -> DuckDBArrowSchema -> IO ()
$cpoke :: Ptr DuckDBArrowSchema -> DuckDBArrowSchema -> IO ()
peek :: Ptr DuckDBArrowSchema -> IO DuckDBArrowSchema
$cpeek :: Ptr DuckDBArrowSchema -> IO DuckDBArrowSchema
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBArrowSchema -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBArrowSchema -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBArrowSchema
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBArrowSchema
pokeElemOff :: Ptr DuckDBArrowSchema -> Int -> DuckDBArrowSchema -> IO ()
$cpokeElemOff :: Ptr DuckDBArrowSchema -> Int -> DuckDBArrowSchema -> IO ()
peekElemOff :: Ptr DuckDBArrowSchema -> Int -> IO DuckDBArrowSchema
$cpeekElemOff :: Ptr DuckDBArrowSchema -> Int -> IO DuckDBArrowSchema
alignment :: DuckDBArrowSchema -> Int
$calignment :: DuckDBArrowSchema -> Int
sizeOf :: DuckDBArrowSchema -> Int
$csizeOf :: DuckDBArrowSchema -> Int
Storable)

newtype DuckDBArrowArray = DuckDBArrowArray (Ptr ()) deriving (DuckDBArrowArray -> DuckDBArrowArray -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBArrowArray -> DuckDBArrowArray -> Bool
$c/= :: DuckDBArrowArray -> DuckDBArrowArray -> Bool
== :: DuckDBArrowArray -> DuckDBArrowArray -> Bool
$c== :: DuckDBArrowArray -> DuckDBArrowArray -> Bool
Eq, Ptr DuckDBArrowArray -> IO DuckDBArrowArray
Ptr DuckDBArrowArray -> Int -> IO DuckDBArrowArray
Ptr DuckDBArrowArray -> Int -> DuckDBArrowArray -> IO ()
Ptr DuckDBArrowArray -> DuckDBArrowArray -> IO ()
DuckDBArrowArray -> Int
forall b. Ptr b -> Int -> IO DuckDBArrowArray
forall b. Ptr b -> Int -> DuckDBArrowArray -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBArrowArray -> DuckDBArrowArray -> IO ()
$cpoke :: Ptr DuckDBArrowArray -> DuckDBArrowArray -> IO ()
peek :: Ptr DuckDBArrowArray -> IO DuckDBArrowArray
$cpeek :: Ptr DuckDBArrowArray -> IO DuckDBArrowArray
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBArrowArray -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBArrowArray -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBArrowArray
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBArrowArray
pokeElemOff :: Ptr DuckDBArrowArray -> Int -> DuckDBArrowArray -> IO ()
$cpokeElemOff :: Ptr DuckDBArrowArray -> Int -> DuckDBArrowArray -> IO ()
peekElemOff :: Ptr DuckDBArrowArray -> Int -> IO DuckDBArrowArray
$cpeekElemOff :: Ptr DuckDBArrowArray -> Int -> IO DuckDBArrowArray
alignment :: DuckDBArrowArray -> Int
$calignment :: DuckDBArrowArray -> Int
sizeOf :: DuckDBArrowArray -> Int
$csizeOf :: DuckDBArrowArray -> Int
Storable)

newtype DuckDBLogicalType = DuckDBLogicalType (Ptr ()) deriving (DuckDBLogicalType -> DuckDBLogicalType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBLogicalType -> DuckDBLogicalType -> Bool
$c/= :: DuckDBLogicalType -> DuckDBLogicalType -> Bool
== :: DuckDBLogicalType -> DuckDBLogicalType -> Bool
$c== :: DuckDBLogicalType -> DuckDBLogicalType -> Bool
Eq, Ptr DuckDBLogicalType -> IO DuckDBLogicalType
Ptr DuckDBLogicalType -> Int -> IO DuckDBLogicalType
Ptr DuckDBLogicalType -> Int -> DuckDBLogicalType -> IO ()
Ptr DuckDBLogicalType -> DuckDBLogicalType -> IO ()
DuckDBLogicalType -> Int
forall b. Ptr b -> Int -> IO DuckDBLogicalType
forall b. Ptr b -> Int -> DuckDBLogicalType -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBLogicalType -> DuckDBLogicalType -> IO ()
$cpoke :: Ptr DuckDBLogicalType -> DuckDBLogicalType -> IO ()
peek :: Ptr DuckDBLogicalType -> IO DuckDBLogicalType
$cpeek :: Ptr DuckDBLogicalType -> IO DuckDBLogicalType
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBLogicalType -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBLogicalType -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBLogicalType
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBLogicalType
pokeElemOff :: Ptr DuckDBLogicalType -> Int -> DuckDBLogicalType -> IO ()
$cpokeElemOff :: Ptr DuckDBLogicalType -> Int -> DuckDBLogicalType -> IO ()
peekElemOff :: Ptr DuckDBLogicalType -> Int -> IO DuckDBLogicalType
$cpeekElemOff :: Ptr DuckDBLogicalType -> Int -> IO DuckDBLogicalType
alignment :: DuckDBLogicalType -> Int
$calignment :: DuckDBLogicalType -> Int
sizeOf :: DuckDBLogicalType -> Int
$csizeOf :: DuckDBLogicalType -> Int
Storable)

newtype DuckDBDataChunk = DuckDBDataChunk (Ptr ()) deriving (DuckDBDataChunk -> DuckDBDataChunk -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBDataChunk -> DuckDBDataChunk -> Bool
$c/= :: DuckDBDataChunk -> DuckDBDataChunk -> Bool
== :: DuckDBDataChunk -> DuckDBDataChunk -> Bool
$c== :: DuckDBDataChunk -> DuckDBDataChunk -> Bool
Eq, Ptr DuckDBDataChunk -> IO DuckDBDataChunk
Ptr DuckDBDataChunk -> Int -> IO DuckDBDataChunk
Ptr DuckDBDataChunk -> Int -> DuckDBDataChunk -> IO ()
Ptr DuckDBDataChunk -> DuckDBDataChunk -> IO ()
DuckDBDataChunk -> Int
forall b. Ptr b -> Int -> IO DuckDBDataChunk
forall b. Ptr b -> Int -> DuckDBDataChunk -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBDataChunk -> DuckDBDataChunk -> IO ()
$cpoke :: Ptr DuckDBDataChunk -> DuckDBDataChunk -> IO ()
peek :: Ptr DuckDBDataChunk -> IO DuckDBDataChunk
$cpeek :: Ptr DuckDBDataChunk -> IO DuckDBDataChunk
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBDataChunk -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBDataChunk -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBDataChunk
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBDataChunk
pokeElemOff :: Ptr DuckDBDataChunk -> Int -> DuckDBDataChunk -> IO ()
$cpokeElemOff :: Ptr DuckDBDataChunk -> Int -> DuckDBDataChunk -> IO ()
peekElemOff :: Ptr DuckDBDataChunk -> Int -> IO DuckDBDataChunk
$cpeekElemOff :: Ptr DuckDBDataChunk -> Int -> IO DuckDBDataChunk
alignment :: DuckDBDataChunk -> Int
$calignment :: DuckDBDataChunk -> Int
sizeOf :: DuckDBDataChunk -> Int
$csizeOf :: DuckDBDataChunk -> Int
Storable)

newtype DuckDBVector = DuckDBVector (Ptr ()) deriving (DuckDBVector -> DuckDBVector -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBVector -> DuckDBVector -> Bool
$c/= :: DuckDBVector -> DuckDBVector -> Bool
== :: DuckDBVector -> DuckDBVector -> Bool
$c== :: DuckDBVector -> DuckDBVector -> Bool
Eq, Ptr DuckDBVector -> IO DuckDBVector
Ptr DuckDBVector -> Int -> IO DuckDBVector
Ptr DuckDBVector -> Int -> DuckDBVector -> IO ()
Ptr DuckDBVector -> DuckDBVector -> IO ()
DuckDBVector -> Int
forall b. Ptr b -> Int -> IO DuckDBVector
forall b. Ptr b -> Int -> DuckDBVector -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBVector -> DuckDBVector -> IO ()
$cpoke :: Ptr DuckDBVector -> DuckDBVector -> IO ()
peek :: Ptr DuckDBVector -> IO DuckDBVector
$cpeek :: Ptr DuckDBVector -> IO DuckDBVector
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBVector -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBVector -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBVector
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBVector
pokeElemOff :: Ptr DuckDBVector -> Int -> DuckDBVector -> IO ()
$cpokeElemOff :: Ptr DuckDBVector -> Int -> DuckDBVector -> IO ()
peekElemOff :: Ptr DuckDBVector -> Int -> IO DuckDBVector
$cpeekElemOff :: Ptr DuckDBVector -> Int -> IO DuckDBVector
alignment :: DuckDBVector -> Int
$calignment :: DuckDBVector -> Int
sizeOf :: DuckDBVector -> Int
$csizeOf :: DuckDBVector -> Int
Storable)

newtype DuckDBValue = DuckDBValue (Ptr ()) deriving (DuckDBValue -> DuckDBValue -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBValue -> DuckDBValue -> Bool
$c/= :: DuckDBValue -> DuckDBValue -> Bool
== :: DuckDBValue -> DuckDBValue -> Bool
$c== :: DuckDBValue -> DuckDBValue -> Bool
Eq, Ptr DuckDBValue -> IO DuckDBValue
Ptr DuckDBValue -> Int -> IO DuckDBValue
Ptr DuckDBValue -> Int -> DuckDBValue -> IO ()
Ptr DuckDBValue -> DuckDBValue -> IO ()
DuckDBValue -> Int
forall b. Ptr b -> Int -> IO DuckDBValue
forall b. Ptr b -> Int -> DuckDBValue -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBValue -> DuckDBValue -> IO ()
$cpoke :: Ptr DuckDBValue -> DuckDBValue -> IO ()
peek :: Ptr DuckDBValue -> IO DuckDBValue
$cpeek :: Ptr DuckDBValue -> IO DuckDBValue
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBValue -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBValue -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBValue
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBValue
pokeElemOff :: Ptr DuckDBValue -> Int -> DuckDBValue -> IO ()
$cpokeElemOff :: Ptr DuckDBValue -> Int -> DuckDBValue -> IO ()
peekElemOff :: Ptr DuckDBValue -> Int -> IO DuckDBValue
$cpeekElemOff :: Ptr DuckDBValue -> Int -> IO DuckDBValue
alignment :: DuckDBValue -> Int
$calignment :: DuckDBValue -> Int
sizeOf :: DuckDBValue -> Int
$csizeOf :: DuckDBValue -> Int
Storable)

type DuckDBState = Int32

pattern DuckDBSuccess :: DuckDBState
pattern $bDuckDBSuccess :: DuckDBPendingState
$mDuckDBSuccess :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DuckDBSuccess = 0

pattern DuckDBError :: DuckDBState
pattern $bDuckDBError :: DuckDBPendingState
$mDuckDBError :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DuckDBError = 1

{-# COMPLETE
    DuckDBSuccess
    , DuckDBError ::
        DuckDBState
    #-}

type DuckDBPendingState = Int32

pattern DUCKDB_PENDING_RESULT_READY :: DuckDBPendingState
pattern $bDUCKDB_PENDING_RESULT_READY :: DuckDBPendingState
$mDUCKDB_PENDING_RESULT_READY :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_PENDING_RESULT_READY = 0

pattern DUCKDB_PENDING_RESULT_NOT_READY :: DuckDBPendingState
pattern $bDUCKDB_PENDING_RESULT_NOT_READY :: DuckDBPendingState
$mDUCKDB_PENDING_RESULT_NOT_READY :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_PENDING_RESULT_NOT_READY = 1

pattern DUCKDB_PENDING_ERROR :: DuckDBPendingState
pattern $bDUCKDB_PENDING_ERROR :: DuckDBPendingState
$mDUCKDB_PENDING_ERROR :: forall {r}. DuckDBPendingState -> ((# #) -> r) -> ((# #) -> r) -> r
DUCKDB_PENDING_ERROR = 2

{-# COMPLETE
    DUCKDB_PENDING_RESULT_READY
    , DUCKDB_PENDING_RESULT_NOT_READY
    , DUCKDB_PENDING_ERROR ::
        DuckDBPendingState
    #-}

-----------------------------------------------------
-- Open/Connect
-----------------------------------------------------

foreign import ccall "duckdb.h duckdb_open"
    duckdb_open
        :: CString -> Ptr DuckDBDatabase -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_open_ext"
    duckdb_open_ext
        :: CString -> Ptr DuckDBDatabase -> DuckDBConfig -> Ptr CString -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_close"
    duckdb_close
        :: Ptr DuckDBDatabase -> IO ()

foreign import ccall "duckdb.h duckdb_connect"
    duckdb_connect
        :: DuckDBDatabase -> Ptr DuckDBConnection -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_disconnect"
    duckdb_disconnect
        :: Ptr DuckDBConnection -> IO ()

foreign import ccall "duckdb.h duckdb_library_version"
    duckdb_library_version
        :: IO CString

-----------------------------------------------------
-- Configuration
-----------------------------------------------------

foreign import ccall "duckdb.h duckdb_create_config"
    duckdb_create_config
        :: Ptr DuckDBConfig -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_config_count"
    duckdb_config_count
        :: IO CSize

foreign import ccall "duckdb.h duckdb_get_config_flag"
    duckdb_get_config_flag
        :: CSize -> Ptr CString -> Ptr CString -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_set_config"
    duckdb_set_config
        :: DuckDBConfig -> CString -> CString -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_destroy_config"
    duckdb_destroy_config
        :: Ptr DuckDBConfig -> IO ()

-----------------------------------------------------
-- Query Execution
-----------------------------------------------------

foreign import ccall "duckdb.h duckdb_query"
    duckdb_query
        :: DuckDBConnection -> CString -> Ptr DuckDBResult -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_destroy_result"
    duckdb_destroy_result
        :: Ptr DuckDBResult -> IO ()

foreign import ccall "duckdb.h duckdb_column_name"
    duckdb_column_name
        :: Ptr DuckDBResult -> DuckDBIndexType -> IO CString

foreign import ccall "duckdb.h duckdb_column_type"
    duckdb_column_type
        :: Ptr DuckDBResult -> DuckDBIndexType -> IO DuckDBType

foreign import ccall "duckdb.h duckdb_column_logical_type"
    duckdb_column_logical_type
        :: Ptr DuckDBResult -> DuckDBIndexType -> IO DuckDBLogicalType

foreign import ccall "duckdb.h duckdb_column_count"
    duckdb_column_count
        :: Ptr DuckDBResult -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_row_count"
    duckdb_row_count
        :: Ptr DuckDBResult -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_rows_changed"
    duckdb_rows_changed
        :: Ptr DuckDBResult -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_column_data"
    duckdb_column_data
        :: Ptr DuckDBResult -> DuckDBIndexType -> IO (Ptr a)

foreign import ccall "duckdb.h duckdb_nullmask_data"
    duckdb_nullmask_data
        :: Ptr DuckDBResult -> DuckDBIndexType -> IO (Ptr Bool)

foreign import ccall "duckdb.h duckdb_result_error"
    duckdb_result_error
        :: Ptr DuckDBResult -> IO CString

-----------------------------------------------------
-- Result Functions
-----------------------------------------------------

foreign import ccall "duckdb.h duckdb_result_get_chunk_capi"
    duckdb_result_get_chunk
        :: Ptr DuckDBResult -> DuckDBIndexType -> IO DuckDBDataChunk

foreign import ccall "duckdb.h duckdb_result_is_streaming_capi"
    duckdb_result_is_streaming
        :: Ptr DuckDBResult -> IO Bool

foreign import ccall "duckdb.h duckdb_result_chunk_count_capi"
    duckdb_result_chunk_count
        :: Ptr DuckDBResult -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_value_boolean"
    duckdb_value_boolean
        :: Ptr DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Bool

foreign import ccall "duckdb.h duckdb_value_int8"
    duckdb_value_int8
        :: Ptr DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Int8

foreign import ccall "duckdb.h duckdb_value_int16"
    duckdb_value_int16
        :: Ptr DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Int16

foreign import ccall "duckdb.h duckdb_value_int32"
    duckdb_value_int32
        :: Ptr DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Int32

foreign import ccall "duckdb.h duckdb_value_int64"
    duckdb_value_int64
        :: Ptr DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Int64

-- DUCKDB_API duckdb_hugeint duckdb_value_hugeint(duckdb_result *result, idx_t col, idx_t row);

-- DUCKDB_API duckdb_decimal duckdb_value_decimal(duckdb_result *result, idx_t col, idx_t row);

foreign import ccall "duckdb.h duckdb_value_uint8"
    duckdb_value_uint8
        :: Ptr DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Word8

foreign import ccall "duckdb.h duckdb_value_uint16"
    duckdb_value_uint16
        :: Ptr DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Word16

foreign import ccall "duckdb.h duckdb_value_uint32"
    duckdb_value_uint32
        :: Ptr DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Word32

foreign import ccall "duckdb.h duckdb_value_uint64"
    duckdb_value_uint64
        :: Ptr DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Word64

foreign import ccall "duckdb.h duckdb_value_float"
    duckdb_value_float
        :: Ptr DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Float

foreign import ccall "duckdb.h duckdb_value_double"
    duckdb_value_double
        :: Ptr DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Double

foreign import ccall "duckdb.h duckdb_value_date"
    duckdb_value_date
        :: Ptr DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO DuckDBDate

foreign import ccall "duckdb.h duckdb_value_time"
    duckdb_value_time
        :: Ptr DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO DuckDBTime

foreign import ccall "duckdb.h duckdb_value_timestamp"
    duckdb_value_timestamp
        :: Ptr DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO DuckDBTimestamp

-- DUCKDB_API duckdb_interval duckdb_value_interval(duckdb_result *result, idx_t col, idx_t row);

foreign import ccall "duckdb.h duckdb_value_varchar"
    duckdb_value_varchar
        :: Ptr DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO CString

-- DUCKDB_API duckdb_string duckdb_value_string(duckdb_result *result, idx_t col, idx_t row);

foreign import ccall "duckdb.h duckdb_value_varchar_internal"
    duckdb_value_varchar_internal
        :: Ptr DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO CString

-- DUCKDB_API duckdb_string duckdb_value_string_internal(duckdb_result *result, idx_t col, idx_t row);

-- DUCKDB_API duckdb_blob duckdb_value_blob(duckdb_result *result, idx_t col, idx_t row);

foreign import ccall "duckdb.h duckdb_value_is_null"
    duckdb_value_is_null
        :: Ptr DuckDBResult -> DuckDBIndexType -> DuckDBIndexType -> IO Bool

-----------------------------------------------------
-- Helpers
-----------------------------------------------------

foreign import ccall "duckdb.h duckdb_malloc"
    duckdb_malloc
        :: CSize -> IO (Ptr a)

foreign import ccall "duckdb.h duckdb_free"
    duckdb_free
        :: Ptr a -> IO ()

foreign import ccall "duckdb.h duckdb_vector_size"
    duckdb_vector_size
        :: IO DuckDBIndexType

-- DUCKDB_API bool duckdb_string_is_inlined(duckdb_string_t string);

-----------------------------------------------------
-- Date/Time/Timestamp Helpers
-----------------------------------------------------

-- DUCKDB_API duckdb_date_struct duckdb_from_date(duckdb_date date);

-- DUCKDB_API duckdb_date duckdb_to_date(duckdb_date_struct date);

-- DUCKDB_API duckdb_time_struct duckdb_from_time(duckdb_time time);

-- DUCKDB_API duckdb_time duckdb_to_time(duckdb_time_struct time);

-- DUCKDB_API duckdb_timestamp_struct duckdb_from_timestamp(duckdb_timestamp ts);

-- DUCKDB_API duckdb_timestamp duckdb_to_timestamp(duckdb_timestamp_struct ts);

-----------------------------------------------------
-- Hugeint Helpers
-----------------------------------------------------

-- DUCKDB_API double duckdb_hugeint_to_double(duckdb_hugeint val);

-- DUCKDB_API duckdb_hugeint duckdb_double_to_hugeint(double val);

-----------------------------------------------------
-- Decimal Helpers
-----------------------------------------------------

-- DUCKDB_API duckdb_decimal duckdb_double_to_decimal(double val, uint8_t width, uint8_t scale);

-- DUCKDB_API double duckdb_decimal_to_double(duckdb_decimal val);

-----------------------------------------------------
-- Prepared Statements
-----------------------------------------------------

foreign import ccall "duckdb.h duckdb_prepare"
    duckdb_prepare
        :: DuckDBConnection -> CString -> Ptr DuckDBPreparedStatement -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_destroy_prepare"
    duckdb_destroy_prepare
        :: Ptr DuckDBPreparedStatement -> IO ()

foreign import ccall "duckdb.h duckdb_prepare_error"
    duckdb_prepare_error
        :: DuckDBPreparedStatement -> IO CString

foreign import ccall "duckdb.h duckdb_nparams"
    duckdb_nparams
        :: DuckDBPreparedStatement -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_param_type"
    duckdb_param_type
        :: DuckDBPreparedStatement -> DuckDBIndexType -> IO DuckDBType

foreign import ccall "duckdb.h duckdb_clear_bindings"
    duckdb_clear_bindings
        :: DuckDBPreparedStatement -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_bind_boolean"
    duckdb_bind_boolean
        :: DuckDBPreparedStatement -> DuckDBIndexType -> Bool -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_bind_int8"
    duckdb_bind_int8
        :: DuckDBPreparedStatement -> DuckDBIndexType -> Int8 -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_bind_int16"
    duckdb_bind_int16
        :: DuckDBPreparedStatement -> DuckDBIndexType -> Int16 -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_bind_int32"
    duckdb_bind_int32
        :: DuckDBPreparedStatement -> DuckDBIndexType -> Int32 -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_bind_int64"
    duckdb_bind_int64
        :: DuckDBPreparedStatement -> DuckDBIndexType -> Int64 -> IO DuckDBState

-- DUCKDB_API duckdb_state duckdb_bind_hugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx,
--                                             duckdb_hugeint val);

-- DUCKDB_API duckdb_state duckdb_bind_decimal(duckdb_prepared_statement prepared_statement, idx_t param_idx,
--                                             duckdb_decimal val);

foreign import ccall "duckdb.h duckdb_bind_uint8"
    duckdb_bind_uint8
        :: DuckDBPreparedStatement -> DuckDBIndexType -> Word8 -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_bind_uint16"
    duckdb_bind_uint16
        :: DuckDBPreparedStatement -> DuckDBIndexType -> Word16 -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_bind_uint32"
    duckdb_bind_uint32
        :: DuckDBPreparedStatement -> DuckDBIndexType -> Word32 -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_bind_uint64"
    duckdb_bind_uint64
        :: DuckDBPreparedStatement -> DuckDBIndexType -> Word64 -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_bind_float"
    duckdb_bind_float
        :: DuckDBPreparedStatement -> DuckDBIndexType -> Float -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_bind_double"
    duckdb_bind_double
        :: DuckDBPreparedStatement -> DuckDBIndexType -> Double -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_bind_date"
    duckdb_bind_date
        :: DuckDBPreparedStatement -> DuckDBIndexType -> DuckDBDate -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_bind_time"
    duckdb_bind_time
        :: DuckDBPreparedStatement -> DuckDBIndexType -> DuckDBTime -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_bind_timestamp"
    duckdb_bind_timestamp
        :: DuckDBPreparedStatement -> DuckDBIndexType -> DuckDBTimestamp -> IO DuckDBState

-- DUCKDB_API duckdb_state duckdb_bind_interval(duckdb_prepared_statement prepared_statement, idx_t param_idx,
--                                              duckdb_interval val);

foreign import ccall "duckdb.h duckdb_bind_varchar"
    duckdb_bind_varchar
        :: DuckDBPreparedStatement -> DuckDBIndexType -> CString -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_bind_varchar_length"
    duckdb_bind_varchar_length
        :: DuckDBPreparedStatement
        -> DuckDBIndexType
        -> CString
        -> DuckDBIndexType
        -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_bind_blob"
    duckdb_bind_blob
        :: DuckDBPreparedStatement
        -> DuckDBIndexType
        -> Ptr ()
        -> DuckDBIndexType
        -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_bind_null"
    duckdb_bind_null
        :: DuckDBPreparedStatement -> DuckDBIndexType -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_execute_prepared"
    duckdb_execute_prepared
        :: DuckDBPreparedStatement -> Ptr DuckDBResult -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_execute_prepared_arrow"
    duckdb_execute_prepared_arrow
        :: DuckDBPreparedStatement -> Ptr DuckDBArrow -> IO DuckDBState

-----------------------------------------------------
-- Extract Statements
-----------------------------------------------------

foreign import ccall "duckdb.h duckdb_extract_statements"
    duckdb_extract_statements
        :: DuckDBConnection
        -> CString
        -> Ptr DuckDBExtractedStatements
        -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_prepare_extracted_statement"
    duckdb_prepare_extracted_statement
        :: DuckDBConnection
        -> DuckDBExtractedStatements
        -> DuckDBIndexType
        -> Ptr DuckDBPreparedStatement
        -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_extract_statements_error"
    duckdb_extract_statements_error
        :: DuckDBExtractedStatements -> IO CString

foreign import ccall "duckdb.h duckdb_destroy_extracted"
    duckdb_destroy_extracted
        :: Ptr DuckDBExtractedStatements -> IO ()

-----------------------------------------------------
-- Pending Result Interface
-----------------------------------------------------

foreign import ccall "duckdb.h duckdb_pending_prepared"
    duckdb_pending_prepared
        :: DuckDBPreparedStatement -> Ptr DuckDBPendingResult -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_pending_prepared_streaming"
    duckdb_pending_prepared_streaming
        :: DuckDBPreparedStatement -> Ptr DuckDBPendingResult -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_destroy_pending"
    duckdb_destroy_pending
        :: Ptr DuckDBPendingResult -> IO ()

foreign import ccall "duckdb.h duckdb_pending_error"
    duckdb_pending_error
        :: DuckDBPendingResult -> IO CString

foreign import ccall "duckdb.h duckdb_pending_execute_task"
    duckdb_pending_execute_task
        :: DuckDBPendingResult -> IO DuckDBPendingState

foreign import ccall "duckdb.h duckdb_execute_pending"
    duckdb_execute_pending
        :: DuckDBPendingResult -> Ptr DuckDBResult -> IO DuckDBState

-----------------------------------------------------
-- Value Interface
-----------------------------------------------------

foreign import ccall "duckdb.h duckdb_destroy_value"
    duckdb_destroy_value
        :: Ptr DuckDBValue -> IO ()

foreign import ccall "duckdb.h duckdb_create_varchar"
    duckdb_create_varchar
        :: CString -> IO DuckDBValue

foreign import ccall "duckdb.h duckdb_create_varchar_length"
    duckdb_create_varchar_length
        :: CString -> DuckDBIndexType -> IO DuckDBValue

foreign import ccall "duckdb.h duckdb_create_int64"
    duckdb_create_int64
        :: Int64 -> IO DuckDBValue

foreign import ccall "duckdb.h duckdb_get_varchar"
    duckdb_get_varchar
        :: DuckDBValue -> IO CString

foreign import ccall "duckdb.h duckdb_get_int64"
    duckdb_get_int64
        :: DuckDBValue -> IO Int64

-----------------------------------------------------
-- Logical Type Interface
-----------------------------------------------------

foreign import ccall "duckdb.h duckdb_create_logical_type"
    duckdb_create_logical_type
        :: DuckDBType -> IO DuckDBLogicalType

foreign import ccall "duckdb.h duckdb_create_list_type"
    duckdb_create_list_type
        :: DuckDBLogicalType -> IO DuckDBLogicalType

foreign import ccall "duckdb.h duckdb_create_map_type"
    duckdb_create_map_type
        :: DuckDBLogicalType -> DuckDBLogicalType -> IO DuckDBLogicalType

foreign import ccall "duckdb.h duckdb_create_union_type"
    duckdb_create_union_type
        :: Ptr DuckDBLogicalType -> Ptr CString -> DuckDBIndexType -> IO DuckDBLogicalType

foreign import ccall "duckdb.h duckdb_create_decimal_type"
    duckdb_create_decimal_type
        :: Word8 -> Word8 -> IO DuckDBLogicalType

foreign import ccall "duckdb.h duckdb_get_type_id"
    duckdb_get_type_id
        :: DuckDBLogicalType -> IO DuckDBType

foreign import ccall "duckdb.h duckdb_decimal_width"
    duckdb_decimal_width
        :: DuckDBLogicalType -> IO Word8

foreign import ccall "duckdb.h duckdb_decimal_scale"
    duckdb_decimal_scale
        :: DuckDBLogicalType -> IO Word8

foreign import ccall "duckdb.h duckdb_decimal_internal_type"
    duckdb_decimal_internal_type
        :: DuckDBLogicalType -> IO DuckDBType

foreign import ccall "duckdb.h duckdb_enum_internal_type"
    duckdb_enum_internal_type
        :: DuckDBLogicalType -> IO DuckDBType

foreign import ccall "duckdb.h duckdb_enum_dictionary_size"
    duckdb_enum_dictionary_size
        :: DuckDBLogicalType -> IO Word32

foreign import ccall "duckdb.h duckdb_enum_dictionary_value"
    duckdb_enum_dictionary_value
        :: DuckDBLogicalType -> DuckDBIndexType -> IO CString

foreign import ccall "duckdb.h duckdb_list_type_child_type"
    duckdb_list_type_child_type
        :: DuckDBLogicalType -> IO DuckDBLogicalType

foreign import ccall "duckdb.h duckdb_map_type_key_type"
    duckdb_map_type_key_type
        :: DuckDBLogicalType -> IO DuckDBLogicalType

foreign import ccall "duckdb.h duckdb_map_type_value_type"
    duckdb_map_type_value_type
        :: DuckDBLogicalType -> IO DuckDBLogicalType

foreign import ccall "duckdb.h duckdb_struct_type_child_count"
    duckdb_struct_type_child_count
        :: DuckDBLogicalType -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_struct_type_child_name"
    duckdb_struct_type_child_name
        :: DuckDBLogicalType -> DuckDBIndexType -> IO CString

foreign import ccall "duckdb.h duckdb_struct_type_child_type"
    duckdb_struct_type_child_type
        :: DuckDBLogicalType -> DuckDBIndexType -> IO DuckDBLogicalType

foreign import ccall "duckdb.h duckdb_union_type_member_count"
    duckdb_union_type_member_count
        :: DuckDBLogicalType -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_union_type_member_name"
    duckdb_union_type_member_name
        :: DuckDBLogicalType -> DuckDBIndexType -> IO CString

foreign import ccall "duckdb.h duckdb_union_type_member_type"
    duckdb_union_type_member_type
        :: DuckDBLogicalType -> DuckDBIndexType -> IO DuckDBLogicalType

foreign import ccall "duckdb.h duckdb_destroy_logical_type"
    duckdb_destroy_logical_type
        :: Ptr DuckDBLogicalType -> IO ()

-----------------------------------------------------
-- Data Chunk Interface
-----------------------------------------------------

foreign import ccall "duckdb.h duckdb_create_data_chunk"
    duckdb_create_data_chunk
        :: Ptr DuckDBLogicalType -> DuckDBIndexType -> IO DuckDBDataChunk

foreign import ccall "duckdb.h duckdb_destroy_data_chunk"
    duckdb_destroy_data_chunk
        :: Ptr DuckDBDataChunk -> IO ()

foreign import ccall "duckdb.h duckdb_data_chunk_reset"
    duckdb_data_chunk_reset
        :: DuckDBDataChunk -> IO ()

foreign import ccall "duckdb.h duckdb_data_chunk_get_column_count"
    duckdb_data_chunk_get_column_count
        :: DuckDBDataChunk -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_data_chunk_get_vector"
    duckdb_data_chunk_get_vector
        :: DuckDBDataChunk -> DuckDBIndexType -> IO DuckDBVector

foreign import ccall "duckdb.h duckdb_data_chunk_get_size"
    duckdb_data_chunk_get_size
        :: DuckDBDataChunk -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_data_chunk_set_size"
    duckdb_data_chunk_set_size
        :: DuckDBDataChunk -> DuckDBIndexType -> IO ()

-----------------------------------------------------
-- Vector Interface
-----------------------------------------------------
foreign import ccall "duckdb.h duckdb_vector_get_column_type"
    duckdb_vector_get_column_type
        :: DuckDBVector -> IO DuckDBLogicalType

foreign import ccall "duckdb.h duckdb_vector_get_data"
    duckdb_vector_get_data
        :: DuckDBVector -> IO (Ptr a)

foreign import ccall "duckdb.h duckdb_vector_get_validity"
    duckdb_vector_get_validity
        :: DuckDBVector -> IO (Ptr Word64)

foreign import ccall "duckdb.h duckdb_vector_ensure_validity_writable"
    duckdb_vector_ensure_validity_writable
        :: DuckDBVector -> IO ()

foreign import ccall "duckdb.h duckdb_vector_assign_string_element"
    duckdb_vector_assign_string_element
        :: DuckDBVector -> DuckDBIndexType -> CString -> IO ()

foreign import ccall "duckdb.h duckdb_vector_assign_string_element_len"
    duckdb_vector_assign_string_element_len
        :: DuckDBVector -> DuckDBIndexType -> CString -> DuckDBIndexType -> IO ()

foreign import ccall "duckdb.h duckdb_list_vector_get_child"
    duckdb_list_vector_get_child
        :: DuckDBVector -> IO DuckDBVector

foreign import ccall "duckdb.h duckdb_list_vector_get_size"
    duckdb_list_vector_get_size
        :: DuckDBVector -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_list_vector_set_size"
    duckdb_list_vector_set_size
        :: DuckDBVector -> DuckDBIndexType -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_list_vector_reserve"
    duckdb_list_vector_reserve
        :: DuckDBVector -> DuckDBIndexType -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_struct_vector_get_child"
    duckdb_struct_vector_get_child
        :: DuckDBVector -> DuckDBIndexType -> IO DuckDBVector

-----------------------------------------------------
-- Validity Mask Functions
-----------------------------------------------------
foreign import ccall "duckdb.h duckdb_validity_row_is_valid"
    duckdb_validity_row_is_valid
        :: Ptr Word64 -> DuckDBIndexType -> IO Bool

foreign import ccall "duckdb.h duckdb_validity_set_row_validity"
    duckdb_validity_set_row_validity
        :: Ptr Word64 -> DuckDBIndexType -> Bool -> IO ()

foreign import ccall "duckdb.h duckdb_validity_set_row_invalid"
    duckdb_validity_set_row_invalid
        :: Ptr Word64 -> DuckDBIndexType -> IO ()

foreign import ccall "duckdb.h duckdb_validity_set_row_valid"
    duckdb_validity_set_row_valid
        :: Ptr Word64 -> DuckDBIndexType -> IO ()

-----------------------------------------------------
-- Table Functions
-----------------------------------------------------

newtype DuckDBTableFunction = DuckDBTableFunction (Ptr ())
    deriving (DuckDBTableFunction -> DuckDBTableFunction -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBTableFunction -> DuckDBTableFunction -> Bool
$c/= :: DuckDBTableFunction -> DuckDBTableFunction -> Bool
== :: DuckDBTableFunction -> DuckDBTableFunction -> Bool
$c== :: DuckDBTableFunction -> DuckDBTableFunction -> Bool
Eq, Ptr DuckDBTableFunction -> IO DuckDBTableFunction
Ptr DuckDBTableFunction -> Int -> IO DuckDBTableFunction
Ptr DuckDBTableFunction -> Int -> DuckDBTableFunction -> IO ()
Ptr DuckDBTableFunction -> DuckDBTableFunction -> IO ()
DuckDBTableFunction -> Int
forall b. Ptr b -> Int -> IO DuckDBTableFunction
forall b. Ptr b -> Int -> DuckDBTableFunction -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBTableFunction -> DuckDBTableFunction -> IO ()
$cpoke :: Ptr DuckDBTableFunction -> DuckDBTableFunction -> IO ()
peek :: Ptr DuckDBTableFunction -> IO DuckDBTableFunction
$cpeek :: Ptr DuckDBTableFunction -> IO DuckDBTableFunction
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBTableFunction -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBTableFunction -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBTableFunction
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBTableFunction
pokeElemOff :: Ptr DuckDBTableFunction -> Int -> DuckDBTableFunction -> IO ()
$cpokeElemOff :: Ptr DuckDBTableFunction -> Int -> DuckDBTableFunction -> IO ()
peekElemOff :: Ptr DuckDBTableFunction -> Int -> IO DuckDBTableFunction
$cpeekElemOff :: Ptr DuckDBTableFunction -> Int -> IO DuckDBTableFunction
alignment :: DuckDBTableFunction -> Int
$calignment :: DuckDBTableFunction -> Int
sizeOf :: DuckDBTableFunction -> Int
$csizeOf :: DuckDBTableFunction -> Int
Storable)

newtype DuckDBBindInfo = DuckDBBindInfo (Ptr ()) deriving (DuckDBBindInfo -> DuckDBBindInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBBindInfo -> DuckDBBindInfo -> Bool
$c/= :: DuckDBBindInfo -> DuckDBBindInfo -> Bool
== :: DuckDBBindInfo -> DuckDBBindInfo -> Bool
$c== :: DuckDBBindInfo -> DuckDBBindInfo -> Bool
Eq, Ptr DuckDBBindInfo -> IO DuckDBBindInfo
Ptr DuckDBBindInfo -> Int -> IO DuckDBBindInfo
Ptr DuckDBBindInfo -> Int -> DuckDBBindInfo -> IO ()
Ptr DuckDBBindInfo -> DuckDBBindInfo -> IO ()
DuckDBBindInfo -> Int
forall b. Ptr b -> Int -> IO DuckDBBindInfo
forall b. Ptr b -> Int -> DuckDBBindInfo -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBBindInfo -> DuckDBBindInfo -> IO ()
$cpoke :: Ptr DuckDBBindInfo -> DuckDBBindInfo -> IO ()
peek :: Ptr DuckDBBindInfo -> IO DuckDBBindInfo
$cpeek :: Ptr DuckDBBindInfo -> IO DuckDBBindInfo
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBBindInfo -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBBindInfo -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBBindInfo
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBBindInfo
pokeElemOff :: Ptr DuckDBBindInfo -> Int -> DuckDBBindInfo -> IO ()
$cpokeElemOff :: Ptr DuckDBBindInfo -> Int -> DuckDBBindInfo -> IO ()
peekElemOff :: Ptr DuckDBBindInfo -> Int -> IO DuckDBBindInfo
$cpeekElemOff :: Ptr DuckDBBindInfo -> Int -> IO DuckDBBindInfo
alignment :: DuckDBBindInfo -> Int
$calignment :: DuckDBBindInfo -> Int
sizeOf :: DuckDBBindInfo -> Int
$csizeOf :: DuckDBBindInfo -> Int
Storable)

newtype DuckDBInitInfo = DuckDBInitInfo (Ptr ()) deriving (DuckDBInitInfo -> DuckDBInitInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBInitInfo -> DuckDBInitInfo -> Bool
$c/= :: DuckDBInitInfo -> DuckDBInitInfo -> Bool
== :: DuckDBInitInfo -> DuckDBInitInfo -> Bool
$c== :: DuckDBInitInfo -> DuckDBInitInfo -> Bool
Eq, Ptr DuckDBInitInfo -> IO DuckDBInitInfo
Ptr DuckDBInitInfo -> Int -> IO DuckDBInitInfo
Ptr DuckDBInitInfo -> Int -> DuckDBInitInfo -> IO ()
Ptr DuckDBInitInfo -> DuckDBInitInfo -> IO ()
DuckDBInitInfo -> Int
forall b. Ptr b -> Int -> IO DuckDBInitInfo
forall b. Ptr b -> Int -> DuckDBInitInfo -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBInitInfo -> DuckDBInitInfo -> IO ()
$cpoke :: Ptr DuckDBInitInfo -> DuckDBInitInfo -> IO ()
peek :: Ptr DuckDBInitInfo -> IO DuckDBInitInfo
$cpeek :: Ptr DuckDBInitInfo -> IO DuckDBInitInfo
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBInitInfo -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBInitInfo -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBInitInfo
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBInitInfo
pokeElemOff :: Ptr DuckDBInitInfo -> Int -> DuckDBInitInfo -> IO ()
$cpokeElemOff :: Ptr DuckDBInitInfo -> Int -> DuckDBInitInfo -> IO ()
peekElemOff :: Ptr DuckDBInitInfo -> Int -> IO DuckDBInitInfo
$cpeekElemOff :: Ptr DuckDBInitInfo -> Int -> IO DuckDBInitInfo
alignment :: DuckDBInitInfo -> Int
$calignment :: DuckDBInitInfo -> Int
sizeOf :: DuckDBInitInfo -> Int
$csizeOf :: DuckDBInitInfo -> Int
Storable)

newtype DuckDBFunctionInfo = DuckDBFunctionInfo (Ptr ()) deriving (DuckDBFunctionInfo -> DuckDBFunctionInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBFunctionInfo -> DuckDBFunctionInfo -> Bool
$c/= :: DuckDBFunctionInfo -> DuckDBFunctionInfo -> Bool
== :: DuckDBFunctionInfo -> DuckDBFunctionInfo -> Bool
$c== :: DuckDBFunctionInfo -> DuckDBFunctionInfo -> Bool
Eq, Ptr DuckDBFunctionInfo -> IO DuckDBFunctionInfo
Ptr DuckDBFunctionInfo -> Int -> IO DuckDBFunctionInfo
Ptr DuckDBFunctionInfo -> Int -> DuckDBFunctionInfo -> IO ()
Ptr DuckDBFunctionInfo -> DuckDBFunctionInfo -> IO ()
DuckDBFunctionInfo -> Int
forall b. Ptr b -> Int -> IO DuckDBFunctionInfo
forall b. Ptr b -> Int -> DuckDBFunctionInfo -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBFunctionInfo -> DuckDBFunctionInfo -> IO ()
$cpoke :: Ptr DuckDBFunctionInfo -> DuckDBFunctionInfo -> IO ()
peek :: Ptr DuckDBFunctionInfo -> IO DuckDBFunctionInfo
$cpeek :: Ptr DuckDBFunctionInfo -> IO DuckDBFunctionInfo
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBFunctionInfo -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBFunctionInfo -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBFunctionInfo
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBFunctionInfo
pokeElemOff :: Ptr DuckDBFunctionInfo -> Int -> DuckDBFunctionInfo -> IO ()
$cpokeElemOff :: Ptr DuckDBFunctionInfo -> Int -> DuckDBFunctionInfo -> IO ()
peekElemOff :: Ptr DuckDBFunctionInfo -> Int -> IO DuckDBFunctionInfo
$cpeekElemOff :: Ptr DuckDBFunctionInfo -> Int -> IO DuckDBFunctionInfo
alignment :: DuckDBFunctionInfo -> Int
$calignment :: DuckDBFunctionInfo -> Int
sizeOf :: DuckDBFunctionInfo -> Int
$csizeOf :: DuckDBFunctionInfo -> Int
Storable)

type DuckDBTableFunctionBindFunc = FunPtr (DuckDBBindInfo -> IO ())

type DuckDBTableFunctionInitFunc = FunPtr (DuckDBInitInfo -> IO ())

type DuckDBTableFunctionFunc =
    FunPtr (DuckDBFunctionInfo -> DuckDBDataChunk -> IO ())

type DuckDBDeleteCallbackFunc = FunPtr (Ptr () -> IO ())

foreign import ccall "duckdb.h duckdb_create_table_function"
    duckdb_create_table_function
        :: IO DuckDBTableFunction

foreign import ccall "duckdb.h duckdb_destroy_table_function"
    duckdb_destroy_table_function
        :: DuckDBTableFunction -> IO ()

foreign import ccall "duckdb.h duckdb_table_function_set_name"
    duckdb_table_function_set_name
        :: DuckDBTableFunction -> CString -> IO ()

foreign import ccall "duckdb.h duckdb_table_function_add_parameter"
    duckdb_table_function_add_parameter
        :: DuckDBTableFunction -> DuckDBLogicalType -> IO ()

foreign import ccall "duckdb.h duckdb_table_function_add_named_parameter"
    duckdb_table_function_add_named_parameter
        :: DuckDBTableFunction -> CString -> DuckDBLogicalType -> IO ()

foreign import ccall "duckdb.h duckdb_table_function_set_extra_info"
    duckdb_table_function_set_extra_info
        :: DuckDBTableFunction -> Ptr () -> DuckDBDeleteCallbackFunc -> IO ()

foreign import ccall "duckdb.h duckdb_table_function_set_bind"
    duckdb_table_function_set_bind
        :: DuckDBTableFunction -> DuckDBTableFunctionBindFunc -> IO ()

foreign import ccall "duckdb.h duckdb_table_function_set_init"
    duckdb_table_function_set_init
        :: DuckDBTableFunction -> DuckDBTableFunctionInitFunc -> IO ()

foreign import ccall "duckdb.h duckdb_table_function_set_local_init"
    duckdb_table_function_set_local_init
        :: DuckDBTableFunction -> DuckDBTableFunctionInitFunc -> IO ()

foreign import ccall "duckdb.h duckdb_table_function_set_function"
    duckdb_table_function_set_function
        :: DuckDBTableFunction -> DuckDBTableFunctionFunc -> IO ()

foreign import ccall "duckdb.h duckdb_table_function_supports_projection_pushdown"
    duckdb_table_function_supports_projection_pushdown
        :: DuckDBTableFunction -> Bool -> IO ()

foreign import ccall "duckdb.h duckdb_register_table_function"
    duckdb_register_table_function
        :: DuckDBConnection -> DuckDBTableFunction -> IO DuckDBState

-----------------------------------------------------
-- Table Function Bind
-----------------------------------------------------

foreign import ccall "duckdb.h duckdb_bind_get_extra_info"
    duckdb_bind_get_extra_info
        :: DuckDBBindInfo -> IO (Ptr ())

foreign import ccall "duckdb.h duckdb_bind_add_result_column"
    duckdb_bind_add_result_column
        :: DuckDBBindInfo -> CString -> DuckDBLogicalType -> IO ()

foreign import ccall "duckdb.h duckdb_bind_get_parameter_count"
    duckdb_bind_get_parameter_count
        :: DuckDBBindInfo -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_bind_get_parameter"
    duckdb_bind_get_parameter
        :: DuckDBBindInfo -> DuckDBIndexType -> IO DuckDBValue

foreign import ccall "duckdb.h duckdb_bind_get_named_parameter"
    duckdb_bind_get_named_parameter
        :: DuckDBBindInfo -> CString -> IO DuckDBValue

foreign import ccall "duckdb.h duckdb_bind_set_bind_data"
    duckdb_bind_set_bind_data
        :: DuckDBBindInfo -> Ptr () -> DuckDBDeleteCallbackFunc -> IO ()

foreign import ccall "duckdb.h duckdb_bind_set_cardinality"
    duckdb_bind_set_cardinality
        :: DuckDBBindInfo -> DuckDBIndexType -> Bool -> IO ()

foreign import ccall "duckdb.h duckdb_bind_set_error"
    duckdb_bind_set_error
        :: DuckDBBindInfo -> CString -> IO ()

-----------------------------------------------------
-- Table Function Init
-----------------------------------------------------

foreign import ccall "duckdb.h duckdb_init_get_extra_info"
    duckdb_init_get_extra_info
        :: DuckDBInitInfo -> IO (Ptr ())

foreign import ccall "duckdb.h duckdb_init_get_bind_data"
    duckdb_init_get_bind_data
        :: DuckDBInitInfo -> IO (Ptr ())

foreign import ccall "duckdb.h duckdb_init_set_init_data"
    duckdb_init_set_init_data
        :: DuckDBInitInfo -> Ptr () -> DuckDBDeleteCallbackFunc -> IO ()

foreign import ccall "duckdb.h duckdb_init_get_column_count"
    duckdb_init_get_column_count
        :: DuckDBInitInfo -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_init_get_column_index"
    duckdb_init_get_column_index
        :: DuckDBInitInfo -> DuckDBIndexType -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_init_set_max_threads"
    duckdb_init_set_max_threads
        :: DuckDBInitInfo -> DuckDBIndexType -> IO ()

foreign import ccall "duckdb.h duckdb_init_set_error"
    duckdb_init_set_error
        :: DuckDBInitInfo -> CString -> IO ()

-----------------------------------------------------
-- Table Function
-----------------------------------------------------

foreign import ccall "duckdb.h duckdb_function_get_extra_info"
    duckdb_function_get_extra_info
        :: DuckDBFunctionInfo -> IO (Ptr ())

foreign import ccall "duckdb.h duckdb_function_get_bind_data"
    duckdb_function_get_bind_data
        :: DuckDBFunctionInfo -> IO (Ptr ())

foreign import ccall "duckdb.h duckdb_function_get_init_data"
    duckdb_function_get_init_data
        :: DuckDBFunctionInfo -> IO (Ptr ())

foreign import ccall "duckdb.h duckdb_function_get_local_init_data"
    duckdb_function_get_local_init_data
        :: DuckDBFunctionInfo -> IO (Ptr ())

foreign import ccall "duckdb.h duckdb_function_set_error"
    duckdb_function_set_error
        :: DuckDBFunctionInfo -> CString -> IO ()

-----------------------------------------------------
-- Replacement Scans
-----------------------------------------------------

newtype DuckDBReplacementScanInfo = DuckDBReplacementScanInfo (Ptr ())
    deriving (DuckDBReplacementScanInfo -> DuckDBReplacementScanInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBReplacementScanInfo -> DuckDBReplacementScanInfo -> Bool
$c/= :: DuckDBReplacementScanInfo -> DuckDBReplacementScanInfo -> Bool
== :: DuckDBReplacementScanInfo -> DuckDBReplacementScanInfo -> Bool
$c== :: DuckDBReplacementScanInfo -> DuckDBReplacementScanInfo -> Bool
Eq, Ptr DuckDBReplacementScanInfo -> IO DuckDBReplacementScanInfo
Ptr DuckDBReplacementScanInfo
-> Int -> IO DuckDBReplacementScanInfo
Ptr DuckDBReplacementScanInfo
-> Int -> DuckDBReplacementScanInfo -> IO ()
Ptr DuckDBReplacementScanInfo -> DuckDBReplacementScanInfo -> IO ()
DuckDBReplacementScanInfo -> Int
forall b. Ptr b -> Int -> IO DuckDBReplacementScanInfo
forall b. Ptr b -> Int -> DuckDBReplacementScanInfo -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBReplacementScanInfo -> DuckDBReplacementScanInfo -> IO ()
$cpoke :: Ptr DuckDBReplacementScanInfo -> DuckDBReplacementScanInfo -> IO ()
peek :: Ptr DuckDBReplacementScanInfo -> IO DuckDBReplacementScanInfo
$cpeek :: Ptr DuckDBReplacementScanInfo -> IO DuckDBReplacementScanInfo
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBReplacementScanInfo -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBReplacementScanInfo -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBReplacementScanInfo
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBReplacementScanInfo
pokeElemOff :: Ptr DuckDBReplacementScanInfo
-> Int -> DuckDBReplacementScanInfo -> IO ()
$cpokeElemOff :: Ptr DuckDBReplacementScanInfo
-> Int -> DuckDBReplacementScanInfo -> IO ()
peekElemOff :: Ptr DuckDBReplacementScanInfo
-> Int -> IO DuckDBReplacementScanInfo
$cpeekElemOff :: Ptr DuckDBReplacementScanInfo
-> Int -> IO DuckDBReplacementScanInfo
alignment :: DuckDBReplacementScanInfo -> Int
$calignment :: DuckDBReplacementScanInfo -> Int
sizeOf :: DuckDBReplacementScanInfo -> Int
$csizeOf :: DuckDBReplacementScanInfo -> Int
Storable)

type DuckDBReplacementCallbackFunc =
    FunPtr (DuckDBReplacementScanInfo -> CString -> Ptr () -> IO ())

foreign import ccall "duckdb.h duckdb_add_replacement_scan"
    duckdb_add_replacement_scan
        :: DuckDBDatabase
        -> DuckDBReplacementCallbackFunc
        -> Ptr ()
        -> DuckDBDeleteCallbackFunc
        -> IO ()

foreign import ccall "duckdb.h duckdb_replacement_scan_set_function_name"
    duckdb_replacement_scan_set_function_name
        :: DuckDBReplacementScanInfo -> CString -> IO ()

foreign import ccall "duckdb.h duckdb_replacement_scan_add_parameter"
    duckdb_replacement_scan_add_parameter
        :: DuckDBReplacementScanInfo -> DuckDBValue -> IO ()

foreign import ccall "duckdb.h duckdb_replacement_scan_set_error"
    duckdb_replacement_scan_set_error
        :: DuckDBReplacementScanInfo -> CString -> IO ()

-----------------------------------------------------
-- Appender
-----------------------------------------------------

foreign import ccall "duckdb.h duckdb_appender_create"
    duckdb_appender_create
        :: DuckDBConnection
        -> CString
        -> CString
        -> Ptr DuckDBAppender
        -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_appender_error"
    duckdb_appender_error
        :: DuckDBAppender -> IO CString

foreign import ccall "duckdb.h duckdb_appender_flush"
    duckdb_appender_flush
        :: DuckDBAppender -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_appender_close"
    duckdb_appender_close
        :: DuckDBAppender -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_appender_destroy"
    duckdb_appender_destroy
        :: Ptr DuckDBAppender -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_appender_begin_row"
    duckdb_appender_begin_row :: DuckDBAppender -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_appender_end_row"
    duckdb_appender_end_row :: DuckDBAppender -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_append_bool"
    duckdb_append_bool :: DuckDBAppender -> Bool -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_append_int8"
    duckdb_append_int8 :: DuckDBAppender -> Int8 -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_append_int16"
    duckdb_append_int16 :: DuckDBAppender -> Int16 -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_append_int32"
    duckdb_append_int32 :: DuckDBAppender -> Int32 -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_append_int64"
    duckdb_append_int64 :: DuckDBAppender -> Int64 -> IO DuckDBState

-- DUCKDB_API duckdb_state duckdb_append_hugeint(duckdb_appender appender, duckdb_hugeint value);

foreign import ccall "duckdb.h duckdb_append_uint8"
    duckdb_append_uint8 :: DuckDBAppender -> Word8 -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_append_uint16"
    duckdb_append_uint16 :: DuckDBAppender -> Word16 -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_append_uint32"
    duckdb_append_uint32 :: DuckDBAppender -> Word32 -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_append_uint64"
    duckdb_append_uint64 :: DuckDBAppender -> Word64 -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_append_float"
    duckdb_append_float :: DuckDBAppender -> Float -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_append_double"
    duckdb_append_double :: DuckDBAppender -> Double -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_append_date"
    duckdb_append_date :: DuckDBAppender -> DuckDBDate -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_append_time"
    duckdb_append_time :: DuckDBAppender -> DuckDBTime -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_append_timestamp"
    duckdb_append_timestamp :: DuckDBAppender -> DuckDBTimestamp -> IO DuckDBState

-- DUCKDB_API duckdb_state duckdb_append_interval(duckdb_appender appender, duckdb_interval value);

foreign import ccall "duckdb.h duckdb_append_varchar"
    duckdb_append_varchar :: DuckDBAppender -> CString -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_append_varchar_length"
    duckdb_append_varchar_length
        :: DuckDBAppender -> CString -> DuckDBIndexType -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_append_blob"
    duckdb_append_blob
        :: DuckDBAppender -> Ptr () -> DuckDBIndexType -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_append_null"
    duckdb_append_null :: DuckDBAppender -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_append_data_chunk"
    duckdb_append_data_chunk :: DuckDBAppender -> DuckDBDataChunk -> IO DuckDBState

-----------------------------------------------------
-- Arrow Interface
-----------------------------------------------------

foreign import ccall "duckdb.h duckdb_query_arrow"
    duckdb_query_arrow
        :: DuckDBConnection -> CString -> Ptr DuckDBArrow -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_query_arrow_schema"
    duckdb_query_arrow_schema
        :: DuckDBArrow -> Ptr DuckDBArrowSchema -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_query_arrow_array"
    duckdb_query_arrow_array
        :: DuckDBArrow -> Ptr DuckDBArrowArray -> IO DuckDBState

foreign import ccall "duckdb.h duckdb_arrow_column_count"
    duckdb_arrow_column_count :: DuckDBArrow -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_arrow_row_count"
    duckdb_arrow_row_count :: DuckDBArrow -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_arrow_rows_changed"
    duckdb_arrow_rows_changed :: DuckDBArrow -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_query_arrow_error"
    duckdb_query_arrow_error :: DuckDBArrow -> IO CString

foreign import ccall "duckdb.h duckdb_destroy_arrow"
    duckdb_destroy_arrow :: DuckDBArrow -> IO ()

-----------------------------------------------------
-- Threading Information
-----------------------------------------------------

newtype DuckDBTaskState = DuckDBTaskState (Ptr ()) deriving (DuckDBTaskState -> DuckDBTaskState -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DuckDBTaskState -> DuckDBTaskState -> Bool
$c/= :: DuckDBTaskState -> DuckDBTaskState -> Bool
== :: DuckDBTaskState -> DuckDBTaskState -> Bool
$c== :: DuckDBTaskState -> DuckDBTaskState -> Bool
Eq, Ptr DuckDBTaskState -> IO DuckDBTaskState
Ptr DuckDBTaskState -> Int -> IO DuckDBTaskState
Ptr DuckDBTaskState -> Int -> DuckDBTaskState -> IO ()
Ptr DuckDBTaskState -> DuckDBTaskState -> IO ()
DuckDBTaskState -> Int
forall b. Ptr b -> Int -> IO DuckDBTaskState
forall b. Ptr b -> Int -> DuckDBTaskState -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DuckDBTaskState -> DuckDBTaskState -> IO ()
$cpoke :: Ptr DuckDBTaskState -> DuckDBTaskState -> IO ()
peek :: Ptr DuckDBTaskState -> IO DuckDBTaskState
$cpeek :: Ptr DuckDBTaskState -> IO DuckDBTaskState
pokeByteOff :: forall b. Ptr b -> Int -> DuckDBTaskState -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DuckDBTaskState -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO DuckDBTaskState
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DuckDBTaskState
pokeElemOff :: Ptr DuckDBTaskState -> Int -> DuckDBTaskState -> IO ()
$cpokeElemOff :: Ptr DuckDBTaskState -> Int -> DuckDBTaskState -> IO ()
peekElemOff :: Ptr DuckDBTaskState -> Int -> IO DuckDBTaskState
$cpeekElemOff :: Ptr DuckDBTaskState -> Int -> IO DuckDBTaskState
alignment :: DuckDBTaskState -> Int
$calignment :: DuckDBTaskState -> Int
sizeOf :: DuckDBTaskState -> Int
$csizeOf :: DuckDBTaskState -> Int
Storable)

foreign import ccall "duckdb.h duckdb_execute_tasks"
    duckdb_execute_tasks :: DuckDBDatabase -> DuckDBIndexType -> IO ()

foreign import ccall "duckdb.h duckdb_create_task_state"
    duckdb_create_task_state :: DuckDBDatabase -> IO DuckDBTaskState

foreign import ccall "duckdb.h duckdb_execute_tasks_state"
    duckdb_execute_tasks_state :: DuckDBTaskState -> IO ()

foreign import ccall "duckdb.h duckdb_execute_n_tasks_state"
    duckdb_execute_n_tasks_state
        :: DuckDBTaskState -> DuckDBIndexType -> IO DuckDBIndexType

foreign import ccall "duckdb.h duckdb_finish_execution"
    duckdb_finish_execution :: DuckDBTaskState -> IO ()

foreign import ccall "duckdb.h duckdb_task_state_is_finished"
    duckdb_task_state_is_finished :: DuckDBTaskState -> IO Bool

foreign import ccall "duckdb.h duckdb_destroy_task_state"
    duckdb_destroy_task_state :: DuckDBTaskState -> IO ()

foreign import ccall "duckdb.h duckdb_execution_is_finished"
    duckdb_execution_is_finished :: DuckDBConnection -> IO Bool

-----------------------------------------------------
-- Streaming Result Interface
-----------------------------------------------------

foreign import ccall "duckdb.h duckdb_stream_fetch_chunk_capi"
    duckdb_stream_fetch_chunk :: Ptr DuckDBResult -> IO DuckDBDataChunk